Melior

https://mlir-rs.github.io/melior/melior/
Admin
Melior is a Rust binding for MLIR that provides a simple, safe, and complete API with an ownership...
Tokens:68,883
Snippets:463
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Per-channel Quantization Examples

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/quant/index

Illustrates the application of per-channel quantization with concrete examples for MLIR tensor types. Shows how different dimensions can act as the channel axis with varying scale and zero-point configurations.

```mlir
// A 2x3x4 tensor contains 8-bit signed integers representing 32-bit
// floats. Dimension 1 of the tensor acts as the channel dimension. Its
// size 3 matches the number of provided scale values. Tensor elemenets at
// positions [*][0][*], [*][1][*], and [*][2][*] use scales 3.0, 4.0, and
// 5.0, respectively.
tensor<2x3x4x!quant.uniform<i8:f32:1, {3.0, 4.0, 5.0}>>
```

```mlir
// A 2D dynamically sized tensor contains 16-bit unsigned integers
// representing 32-bit floats. Dimension 0 of the tensor acts as the
// channel dimension. Since 2 scale and zero-point values are provided, the
// size of dimension 0 is expected to be 2 at runtime. Tensor elements
// [0][*] use scale 2.0 and zero point 10, while elements [1][*] use scale
// 3.0 and zero point 20.
tensor<?x?x!quant.uniform<u16:f32:0, {2.0:10, 3.0:20}>>
```

--------------------------------

### Install LLVM/MLIR Dependency

Source: https://mlir-rs.github.io/melior/melior/index

This command installs LLVM/MLIR version 20, a required dependency for the Melior crate, using Homebrew on Linux or macOS. Users on other systems may need to use alternative installation methods.

```bash
brew install llvm@20
```

--------------------------------

### Install Melior Crate

Source: https://mlir-rs.github.io/melior/melior/index

This snippet shows the command to add the Melior crate as a dependency to a Rust project using Cargo. It assumes the user has Rust and Cargo installed.

```bash
cargo add melior
```

--------------------------------

### !quant.uniform Type Examples (Per-layer Quantization)

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/quant/index

Illustrates the usage of the !quant.uniform type for per-layer quantization with different configurations. Examples show specifying storage bounds, scale, and zero point for 8-bit signed and 16-bit unsigned integer representations of 32-bit floats.

```mlir
// An 8-bit signed integer type is used to represent a 32-bit float. No
// clamping information is provided, so the full [-128, 127] range is
// available. The scale is set to 3.0, and the zero point takes its default
// 0 value.
!quant.uniform<i8:f32, 3.0>
```

```mlir
// A 16-bit unsigned integer type is used to represent a 32-bit float. Out
// of the 16 bits, only 10 are used, acoording to the 0..1023 clamping
// range. The type sets the scale to 1.23 and the zero point to 512.
!quant.uniform<u16<0:1023>:f32, 1.23:512>
```

--------------------------------

### Switch Operation Example - MLIR

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/cf/struct

An example demonstrating the usage of the `cf.switch` terminator operation in MLIR. It shows how to switch on a signless integer value, specifying default and case destinations with associated operands.

```mlir
cf.switch %flag : i32,
  [
    default: ^bb1(%a : i32),
    42: ^bb1(%b : i32),
    43: ^bb3(%c : i32)
  ]
```

--------------------------------

### Rust: Initialize MLIR Context and Register Dialects

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Demonstrates how to create an MLIR context and register all available dialects. This is a prerequisite for any MLIR IR manipulation. It utilizes `DialectRegistry` and `register_all_dialects` for a comprehensive setup.

```rust
use melior::{Context, dialect::DialectRegistry, utility::register_all_dialects};

// Create a dialect registry and register all available dialects
let registry = DialectRegistry::new();
register_all_dialects(&registry);

// Create a context and load dialects
let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

// Context is now ready for IR construction
// All subsequent IR objects will hold a reference to this context
assert_eq!(context, context); // Contexts support equality checks
```

--------------------------------

### IRDL Dialect Definition Example

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/irdl/index

This example demonstrates how to define a `cmath` dialect using IRDL. It includes the definition of a `complex` type and a `mul` operation, showcasing the use of SSA constraint operations for defining parameter constraints.

```IRDL
irdl.dialect @cmath {
  irdl.type @complex {
    %0 = irdl.is f32
    %1 = irdl.is f64
    %2 = irdl.any_of(%0, %1)
    irdl.parameters(%2)
  }

  irdl.operation @mul {
    %0 = irdl.is f32
    %1 = irdl.is f64
    %2 = irdl.any_of(%0, %1)
    %3 = irdl.parametric @cmath::@complex<%2>
    irdl.operands(%3, %3)
    irdl.results(%3)
  }
}
```

--------------------------------

### Unpack Operation Example in MLIR

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Demonstrates how to use the tensor.unpack operation in MLIR. It shows examples of converting a packed tensor to a lower-rank tensor with specified inner dimensions and tile sizes, and with an optional outer dimension permutation.

```mlir
// NCnc to NC:
%0 = tensor.unpack %source inner_dims_pos = [0, 1] inner_tiles = [8, 32]
    into %dest : tensor<16x8x8x32xf32> -> tensor<128x256xf32>

// CK to KCck:
%0 = tensor.unpack %source outer_dims_perm = [1, 0] inner_dims_pos = [0, 1]
    inner_tiles = [8, 32] into %dest
    : tensor<8x16x8x32xf32> -> tensor<128x256xf32>
```

--------------------------------

### Build Integer Addition Function in Rust using Melior

Source: https://mlir-rs.github.io/melior/melior/index

This example demonstrates how to build a function that adds two integers using the Melior crate. It involves setting up the MLIR context, defining types, creating a module, and appending operations like `arith.addi` and `func.return`. The code also includes verification of the generated MLIR module.

```rust
use melior {
    Context,
    dialect::{DialectRegistry, arith, func},
    ir::{
        attribute::{StringAttribute, TypeAttribute},
        operation::OperationLike,
        r#type::FunctionType,
        *,
    },
    utility::register_all_dialects,
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);
let module = Module::new(location);

let index_type = Type::index(&context);

module.body().append_operation(func::func(
    &context,
    StringAttribute::new(&context, "add"),
    TypeAttribute::new(
        FunctionType::new(&context, &[index_type, index_type], &[index_type]).into(),
    ),
    {
        let block = Block::new(&[(index_type, location), (index_type, location)]);

        let sum = block
            .append_operation(arith::addi(
                block.argument(0).unwrap().into(),
                block.argument(1).unwrap().into(),
                location,
            ))
            .result(0)
            .unwrap();

        block.append_operation(func::r#return(&[sum.into()], location));

        let region = Region::new();
        region.append_block(block);
        region
    },
    &[],
    location,
));

assert!(module.as_operation().verify());
```

--------------------------------

### Rust: Build MLIR Function with Arithmetic Operation

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Provides a complete example of building an MLIR module containing a function. This function takes two index arguments, adds them using the `arith.addi` operation, and returns the result. It demonstrates dialect registration, function and block creation, and operation insertion.

```rust
use melior::{
    Context,
    dialect::{DialectRegistry, arith, func},
    ir::{
        attribute::{StringAttribute, TypeAttribute},
        operation::OperationLike,
        r#type::FunctionType,
        Block, Location, Module, Region, Type, Value,
    },
    utility::register_all_dialects,
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);
let module = Module::new(location);

// Define the function type: (index, index) -> index
let index_type = Type::index(&context);

// Create the function operation
module.body().append_operation(func::func(
    &context,
    StringAttribute::new(&context, "add"),
    TypeAttribute::new(
        FunctionType::new(&context, &[index_type, index_type], &[index_type]).into()
    ),
    {
        // Create a block with two arguments of index type
        let block = Block::new(&[(index_type, location), (index_type, location)]);

        // Get block arguments and create an addition operation
        let arg0 = block.argument(0).unwrap().into();
        let arg1 = block.argument(1).unwrap().into();

        let sum = block
            .append_operation(arith::addi(arg0, arg1, location))
            .result(0)
            .unwrap();

        // Return the result
        block.append_operation(func::r#return(&[sum.into()], location));

        // Wrap block in a region
        let region = Region::new();
        region.append_block(block);
        region
    },
    &[],
    location,
));

// Verify the module is well-formed
assert!(module.as_operation().verify());
```

--------------------------------

### PDL Pattern Example - MLIR

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/pdl/index

This code snippet demonstrates a basic PDL pattern. It defines a pattern that matches an operation and replaces it with its first operand. PDL patterns use specific operations like `pdl.pattern`, `pdl.operand`, `pdl.operation`, and `pdl.rewrite` to define the matching and rewriting logic.

```mlir
// pdl.pattern contains metadata similarly to a `RewritePattern`.
pdl.pattern : benefit(1) {
  // External input operand values are specified via `pdl.operand` operations.
  // Result types are constrainted via `pdl.type` operations.

  %resultType = pdl.type
  %inputOperand = pdl.operand
  %root = pdl.operation "foo.op"(%inputOperand) -> %resultType
  pdl.rewrite %root {
    pdl.replace %root with (%inputOperand)
  }
}
```

--------------------------------

### Example usage of index.xor operation

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/index/struct

Demonstrates the usage of the 'index.xor' operation in MLIR. This operation takes two index operands (%a, %b) and produces a result (%c) which is the bitwise XOR of the inputs.

```mlir
// c = a ^ b
%c = index.xor %a, %b
```

--------------------------------

### Example Usage of UnrealizedConversionCastOperation

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/builtin/struct

Illustrates various ways to use the unrealized_conversion_cast operation, including 0-1, 1-1, 1-N, and N-1 conversions. These examples show how to represent type conversions that are not immediately realized, useful when a type is removed but not all its uses are converted.

```rust
// An unrealized 0-1 conversion.
// These types of conversions are useful in
// cases where a type is removed from the type system, but not all uses have
// been converted. For example, imagine we have a tuple type that is
// expanded to its element types. If only some uses of an empty tuple type
// instance are converted we still need an instance of the tuple type, but
// have no inputs to the unrealized conversion.
%result = unrealized_conversion_cast to !bar.tuple_type<>
```

```rust
// An unrealized 1-1 conversion.
%result1 = unrealized_conversion_cast %operand : !foo.type to !bar.lowered_type
```

```rust
// An unrealized 1-N conversion.
%results2:2 = unrealized_conversion_cast %tuple_operand : !foo.tuple_type<!foo.type, !foo.type> to !foo.type, !foo.type
```

```rust
// An unrealized N-1 conversion.
%result3 = unrealized_conversion_cast %operand, %operand : !foo.type, !foo.type to !bar.tuple_type<!foo.type, !foo.type>
```

--------------------------------

### UnrealizedConversionCastOperation Implementations

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/builtin/struct

Core implementations for the UnrealizedConversionCastOperation, including methods for getting its name, converting to a generic operation, and building new instances.

```APIDOC
## impl<'c> UnrealizedConversionCastOperation<'c>

### Description
Implementations for the `UnrealizedConversionCastOperation` struct.

### Methods

#### `pub fn name() -> &'static str`
Returns a name for the operation.

#### `pub fn as_operation(&self) -> &Operation<'c>`
Returns a generic `Operation` reference.

#### `pub fn builder( context: &'c Context, location: Location<'c>, ) -> UnrealizedConversionCastOperationBuilder<'c, Unset, Unset>`
Creates a builder for constructing an `UnrealizedConversionCastOperation`.

#### `pub fn outputs(&self) -> impl Iterator<Item = OperationResult<'c, '_>>`
Returns an iterator over the operation's results.

#### `pub fn inputs(&self) -> impl Iterator<Item = Value<'c, '_>>`
Returns an iterator over the operation's input values.
```

--------------------------------

### Rust: Implement Default for LoadStoreOptions

Source: https://mlir-rs.github.io/melior/melior/dialect/llvm/struct

Implements the Default trait for the LoadStoreOptions struct, providing a default configuration for load/store operations. This simplifies initialization by allowing the use of `LoadStoreOptions::default()` to get a standard set of options.

```rust
impl<'c> Default for LoadStoreOptions<'c> {
    fn default() -> LoadStoreOptions<'c>;
}
```

--------------------------------

### Index Dialect Folding Semantics Example

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/index/index

Demonstrates the folding semantics for operations in the Index dialect, specifically illustrating how operations like addition satisfy the property required for consistent folding across different bitwidths. It shows that truncating the result of an operation on 64-bit values is equivalent to truncating the operands first and then performing the operation.

```text
```
trunc(f(a, b)) = f(trunc(a), trunc(b))
```
```

--------------------------------

### x86_amx_tilezeroOperation

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/amx/struct

Represents a `tilezero` operation for x86 AMX instructions. It provides methods to get the operation name, convert to a generic operation, create a builder for the operation, and retrieve operation results.

```APIDOC
## `x86_amx_tilezeroOperation`

### Description
A `tilezero` operation for x86 AMX instructions.

### Methods
- `name() -> &'static str`: Returns the name of the operation.
- `as_operation(&self) -> &Operation<'c>`: Returns a generic representation of the operation.
- `builder(context: &'c Context, location: Location<'c>) -> x86_amx_tilezeroOperationBuilder<'c, Unset>`: Creates a builder to construct the `tilezero` operation.
- `res(&self) -> Result<OperationResult<'c, '_>, Error>`: Retrieves the result of the operation.

### Type Conversions
- `impl<'c> From<x86_amx_tilezeroOperation<'c>> for Operation<'c>`: Converts `x86_amx_tilezeroOperation` into a generic `Operation`.
- `impl<'c> TryFrom<Operation<'c>> for x86_amx_tilezeroOperation<'c>`: Attempts to convert a generic `Operation` into `x86_amx_tilezeroOperation`.
```

--------------------------------

### JIT Compile and Execute MLIR with ExecutionEngine in Rust

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Illustrates the use of `ExecutionEngine` for Just-In-Time (JIT) compilation and execution of MLIR code, leveraging LLVM. This involves setting up the context, defining MLIR functions, and invoking them. Requires `melior` and LLVM translations.

```rust
use melior::
    Context, ExecutionEngine,
    dialect::{DialectRegistry, func, llvm},
    ir::{
        Module, Location, Block, Region, Type,
        attribute::{StringAttribute, TypeAttribute, IntegerAttribute},
        r#type::FunctionType,
        operation::OperationLike,
    },
    utility::{register_all_dialects, register_all_llvm_translations},
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();
register_all_llvm_translations(&context);

let location = Location::unknown(&context);
let module = Module::new(location);

// Define a simple function that returns a constant
let i32_type = Type::integer(&context, 32);
let func_type = FunctionType::new(&context, &[], &[i32_type]);

module.body().append_operation(func::func(
    &context,
    StringAttribute::new(&context, "get_value"),
    TypeAttribute::new(func_type.into()),
    {
        let block = Block::new(&[]);
        let const_op = block.append_operation(llvm::constant(
            &context,
            IntegerAttribute::new(i32_type, 42).into(),
            i32_type,
            location,
        ));
        let value = const_op.result(0).unwrap().into();
        block.append_operation(func::r#return(&[value], location));

        let region = Region::new();
        region.append_block(block);
        region
    },
    &[],
    location,
));

// After lowering to LLVM dialect, create execution engine
let engine = ExecutionEngine::new(&module, 2, &[], false);

// Invoke the function (requires unsafe due to FFI)
// let result: i32 = unsafe { engine.invoke_packed("get_value", &mut []) };
```

--------------------------------

### Index Dialect Division Folding Example

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/index/index

Illustrates a scenario where division in the Index dialect cannot be folded directly due to differing results between 32-bit and 64-bit computations. It highlights operations like division that are sensitive to the upper bits and explains the conditions under which they can be folded.

```text
```
div(0x100000002, 2)
```
```

--------------------------------

### Rust: Create MLIR Module and Verify Structure

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Shows how to create a basic MLIR module within a given context. It includes creating an unknown location and verifying the module's structural integrity. The module can then be converted to its string representation.

```rust
use melior::{Context, ir::{Module, Location}};

let context = Context::new();

// Create a module with an "unknown" location (no source file info)
let location = Location::unknown(&context);
let module = Module::new(location);

// Access the module's body block to add operations
let body = module.body();

// Modules can be verified for correctness
assert!(module.as_operation().verify());

// Convert to string representation
let mlir_text = format!("{}", module.as_operation());
```

--------------------------------

### Rust: LLVM Dialect Integration in Melior

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Shows how to integrate with the LLVM dialect in Melior for low-level code generation. This includes setting up the context, loading dialects, and creating LLVM IR operations like load and store.

```rust
use melior::
    Context,
    dialect::{DialectRegistry, llvm},
    ir::{
        Block, Location, Type,
        attribute::{IntegerAttribute, StringAttribute},
        operation::OperationLike,
    },
    utility::register_all_dialects,
;

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);

// LLVM types
let i32_type = Type::integer(&context, 32);
let ptr_type = llvm::r#type::pointer(&context, 0); // opaque pointer

let block = Block::new(&[]);

// Load and store operations
let addr = block.append_operation(llvm::zero(ptr_type, location)).result(0).unwrap();
let value_const = block.append_operation(llvm::constant(
    &context,
    IntegerAttribute::new(i32_type, 100).into(),
    i32_type,
    location,
)).result(0).unwrap();

let store_op = block.append_operation(llvm::store(
    &context,
    value_const.into(),
    addr.into(),
    location,
));

let load_op = block.append_operation(llvm::load(
    &context,
    addr.into(),
    i32_type,
    location,
));

let loaded_value = load_op.result(0).unwrap();
```

--------------------------------

### melior::dialect::llvm::LoadStoreOptions

Source: https://mlir-rs.github.io/melior/melior/dialect/llvm/struct

Provides options for load and store operations, including alignment, volatility, nontemporal access, and alias scope management.

```APIDOC
## Struct melior::dialect::llvm::LoadStoreOptions

### Description
Load/store options.

### Methods

#### `new()`
Creates load/store options.

- **Return**: `LoadStoreOptions`

#### `align(self, align: Option<IntegerAttribute<'c>>)`
Sets an alignment.

- **Parameters**:
  - `align` (Option<IntegerAttribute>): The alignment value.
- **Return**: `LoadStoreOptions`

#### `volatile(self, volatile: bool)`
Sets a volatile flag.

- **Parameters**:
  - `volatile` (bool): Set to true for volatile access.
- **Return**: `LoadStoreOptions`

#### `nontemporal(self, nontemporal: bool)`
Sets a nontemporal flag.

- **Parameters**:
  - `nontemporal` (bool): Set to true for nontemporal access.
- **Return**: `LoadStoreOptions`

#### `access_groups(self, access_groups: Option<ArrayAttribute<'c>>)`
Sets access groups.

- **Parameters**:
  - `access_groups` (Option<ArrayAttribute>): The access groups.
- **Return**: `LoadStoreOptions`

#### `alias_scopes(self, alias_scopes: Option<ArrayAttribute<'c>>)`
Sets alias scopes.

- **Parameters**:
  - `alias_scopes` (Option<ArrayAttribute>): The alias scopes.
- **Return**: `LoadStoreOptions`

#### `nonalias_scopes(self, noalias_scopes: Option<ArrayAttribute<'c>>)`
Sets noalias scopes.

- **Parameters**:
  - `noalias_scopes` (Option<ArrayAttribute>): The noalias scopes.
- **Return**: `LoadStoreOptions`

#### `tbaa(self, tbaa: ArrayAttribute<'c>)`
Sets TBAA metadata.

- **Parameters**:
  - `tbaa` (ArrayAttribute): The TBAA metadata.
- **Return**: `LoadStoreOptions`

### Trait Implementations

#### `Clone`
- `clone(&self) -> LoadStoreOptions<'c>`: Returns a duplicate of the value.
- `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.

#### `Debug`
- `fmt(&self, f: &mut Formatter<'_>) -> Result`: Formats the value using the given formatter.

#### `Default`
- `default() -> LoadStoreOptions<'c>`: Returns the "default value" for a type.

#### `Copy`
This struct implements the `Copy` trait.
```

--------------------------------

### Create External Pass (Rust)

Source: https://mlir-rs.github.io/melior/melior/pass/external/fn

Defines and creates an external pass using the `create_external` function. This function requires a closure for the pass's execution logic, along with metadata such as pass ID, name, arguments, description, operation name, and dependent dialects. The example demonstrates how to initialize a `Context` and call `create_external` with a simple operation dumping closure.

```rust
use melior::{
    ir::{operation::OperationLike, r#type::TypeId, OperationRef},
    pass::{create_external, ExternalPass},
    Context,
};

#[repr(align(8))]
struct PassId;

static EXAMPLE_PASS: PassId = PassId;

let context = Context::new();

create_external(
    |operation: OperationRef, _pass: ExternalPass| {
        operation.dump();
    },
    TypeId::create(&EXAMPLE_PASS),
    "name",
    "argument",
    "description",
    "",
    &[],
);
```

--------------------------------

### Implement builder() method for x86_amx_tilezeroOperation in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/amx/struct

Implements the `builder()` method for the `x86_amx_tilezeroOperation` struct. This static method creates and returns a builder for constructing new `x86_amx_tilezeroOperation` instances, requiring a context and a location.

```rust
pub fn builder( context: &'c Context, location: Location<'c>, ) -> x86_amx_tilezeroOperationBuilder<'c, Unset>
```

--------------------------------

### Rust: Get nested OperationPassManager

Source: https://mlir-rs.github.io/melior/melior/pass/struct

Retrieves an OperationPassManager that is nested under a specific name. This is useful for applying passes to sub-operations within a module.

```rust
pub fn nested_under(&self, name: &str) -> OperationPassManager<'c, '_>
```

--------------------------------

### Get Source Tensor of UnPackOperation in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Fetches the source tensor `Value` from an UnPackOperation. This is the input tensor that will be unpacked.

```rust
pub fn source(&self) -> Result<Value<'c, '_>, Error>
```

--------------------------------

### Create XOrIOperationBuilder in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/arith/struct

This snippet shows how to initialize an XOrIOperationBuilder for an MLIR 'xori' operation. It requires a context and a location as input.

```rust
pub struct XOrIOperationBuilder<'c, O0, O1> { /* private fields */ }

impl<'c> XOrIOperationBuilder<'c, Unset, Unset> {
    pub fn new(context: &'c Context, location: Location<'c>) -> Self
}
```

--------------------------------

### melior::ir::Value

Source: https://mlir-rs.github.io/melior/melior/ir/struct

Documentation for the `Value` struct, its constructor, and associated trait implementations.

```APIDOC
## struct Value<'c, 'a>

### Description
A value.

### Methods
#### pub unsafe fn from_raw(value: MlirValue) -> Self
Creates a value from a raw object.

##### Safety
A raw object must be valid.

### Trait Implementations
#### impl<'c, 'a> Clone for Value<'c, 'a>
##### fn clone(&self) -> Value<'c, 'a>
Returns a duplicate of the value.

##### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

#### impl Debug for Value<'_, '_>
##### fn fmt(&self, formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

#### impl Display for Value<'_, '_>
##### fn fmt(&self, formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter.

#### impl<'c, 'a> From<BlockArgument<'c, 'a>> for Value<'c, 'a>
##### fn from(value: BlockArgument<'c, 'a>) -> Self
Converts to this type from the input type.

#### impl<'c, 'a> From<OperationResult<'c, 'a>> for Value<'c, 'a>
##### fn from(value: OperationResult<'c, 'a>) -> Self
Converts to this type from the input type.

#### impl PartialEq for Value<'_, '_>
##### fn eq(&self, other: &Self) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

##### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.

#### impl<'c, 'a> TryFrom<Value<'c, 'a>> for BlockArgument<'c, 'a>
##### type Error = Error
##### fn try_from(value: Value<'c, 'a>) -> Result<Self, Self::Error>
Performs the conversion.

#### impl<'c, 'a> TryFrom<Value<'c, 'a>> for OperationResult<'c, 'a>
##### type Error = Error
##### fn try_from(value: Value<'c, 'a>) -> Result<Self, Self::Error>
Performs the conversion.

#### impl<'c> ValueLike<'c> for Value<'c, '_>
##### fn to_raw(&self) -> MlirValue
Converts a value into a raw value.

##### fn type(&self) -> Type<'c>
Returns a type.

##### fn is_block_argument(&self) -> bool
Returns `true` if a value is a block argument.

##### fn is_operation_result(&self) -> bool
Returns `true` if a value is an operation result.

##### fn dump(&self)
Dumps a value.

#### impl<'c, 'a> Copy for Value<'c, 'a>

#### impl Eq for Value<'_, '_>

#### Auto Trait Implementations
- Freeze
- RefUnwindSafe
- !Send
- !Sync
- Unpin
- UnwindSafe

#### Blanket Implementations
- Any
- Borrow
- BorrowMut
- CloneToUninit
- From<T> for T
- Into<U>
- ToOwned
- ToString
- TryFrom<U> for T
- TryInto<U>
```

--------------------------------

### Get Destination Tensor of UnPackOperation in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Retrieves the destination tensor `Value` from an UnPackOperation. This represents the output tensor after unpacking.

```rust
pub fn dest(&self) -> Result<Value<'c, '_>, Error>
```

--------------------------------

### Get Inner Dimensions Position Attribute in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Retrieves the `inner_dims_pos` `Attribute`, which specifies the positions of the inner dimensions to be combined during unpacking.

```rust
pub fn inner_dims_pos(&self) -> Result<Attribute<'c>, Error>
```

--------------------------------

### Rust: Get raw pointer from PassManager

Source: https://mlir-rs.github.io/melior/melior/pass/struct

Returns the underlying raw MLIR pass manager pointer. This method provides access to the C API representation of the PassManager.

```rust
pub const fn to_raw(&self) -> MlirPassManager
```

--------------------------------

### MLIR Arithmetic Operations (Rust)

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Demonstrates the creation and usage of arithmetic operations from the MLIR 'arith' dialect, including addition, subtraction, multiplication, division, and comparison. Requires the 'melior' crate and dialect registration.

```rust
use melior,{
    Context,
    dialect::{DialectRegistry, arith},
    ir::{Block, Location, Type, Value},
    utility::register_all_dialects,
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);
let i32_type = Type::integer(&context, 32);

// Create a block with two arguments
let block = Block::new(&[(i32_type, location), (i32_type, location)]);
let lhs: Value = block.argument(0).unwrap().into();
let rhs: Value = block.argument(1).unwrap().into();

// Integer arithmetic operations
let add = block.append_operation(arith::addi(lhs, rhs, location));
let sub = block.append_operation(arith::subi(lhs, rhs, location));
let mul = block.append_operation(arith::muli(lhs, rhs, location));
let div = block.append_operation(arith::divsi(lhs, rhs, location)); // signed division

// Comparison operations
let cmp = block.append_operation(arith::cmpi(
    &context,
    arith::CmpiPredicate::Eq,
    lhs,
    rhs,
    location,
));

// Extract results
let add_result = add.result(0).unwrap();
```

--------------------------------

### Get Static Inner Tiles Attribute in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Retrieves the static `inner_tiles` `Attribute` if available. This attribute defines the tile sizes for the inner dimensions.

```rust
pub fn static_inner_tiles(&self) -> Result<Attribute<'c>, Error>
```

--------------------------------

### Get Operation Successor Count in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/trait

This Rust code snippet defines the `successor_count` method within the `OperationLike` trait. It returns the number of successor blocks for the operation as a `usize`.

```rust
fn successor_count(&self) -> usize { ... }
```

--------------------------------

### Create MLIR Types (Rust)

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Demonstrates creating various MLIR types such as primitive integers, floats, tensors, memrefs, and function types relative to an MLIR context. Requires the 'melior' crate.

```rust
use melior::{Context, ir::{Type, r#type::{IntegerType, MemRefType, RankedTensorType}}};

let context = Context::new();

// Primitive types
let i32_type = Type::integer(&context, 32);
let i64_type = Type::integer(&context, 64);
let f32_type = Type::float32(&context);
let index_type = Type::index(&context);

// Check type properties
assert!(IntegerType::try_from(i32_type).unwrap().width() == 32);

// Shaped types: tensors and memrefs
let tensor_type = RankedTensorType::new(&[2, 3, 4], f32_type, None);
let memref_type = MemRefType::new(i64_type, &[10, 20], None, None);

// Function types
use melior::ir::r#type::FunctionType;
let func_type = FunctionType::new(&context, &[i32_type, i32_type], &[i32_type]);
```

--------------------------------

### Get Operation Operand Count in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/trait

This Rust code snippet shows the `operand_count` method, part of the `OperationLike` trait. It returns the total number of operands for the operation as a `usize`.

```rust
fn operand_count(&self) -> usize { ... }
```

--------------------------------

### Rust: Handling MLIR Diagnostics

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Demonstrates how to register a diagnostic handler to collect and process error and warning information during MLIR IR construction and transformation. It shows how to attach a handler, capture diagnostics, and detach the handler later.

```rust
use melior::
    Context,
    diagnostic::{Diagnostic, DiagnosticSeverity},
    ir::{Location, Module},
;
use std::sync::{Arc, Mutex};

let context = Context::new();

// Collect diagnostics in a shared vector
let diagnostics = Arc::new(Mutex::new(Vec::new()));
let diagnostics_clone = Arc::clone(&diagnostics);

// Register a diagnostic handler
let handler_id = context.attach_diagnostic_handler(move |diagnostic| {
    let message = diagnostic.message();
    let severity = diagnostic.severity();

    diagnostics_clone.lock().unwrap().push((
        severity,
        message.to_string(),
    ));

    true // Return true to indicate diagnostic was handled
});

// Operations that might produce diagnostics
let location = Location::unknown(&context);
let module = Module::new(location);

// Later, detach the handler
context.detach_diagnostic_handler(handler_id);

// Access collected diagnostics
let collected = diagnostics.lock().unwrap();
for (severity, message) in collected.iter() {
    match severity {
        DiagnosticSeverity::Error => eprintln!("Error: {}", message),
        DiagnosticSeverity::Warning => println!("Warning: {}", message),
        DiagnosticSeverity::Note => println!("Note: {}", message),
        DiagnosticSeverity::Remark => println!("Remark: {}", message),
    }
}
```

--------------------------------

### Get OperationResult Details in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/struct

Provides methods to retrieve information about an `OperationResult`. `result_number` returns the index of the result, and `owner` returns a reference to the operation that produced this result.

```rust
pub fn result_number(&self) -> usize
```

```rust
pub fn owner(&self) -> OperationRef<'c, '_>
```

--------------------------------

### XOrIOperationBuilder

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/arith/struct

A builder for creating a 'xori' operation. This builder allows for the sequential construction of the operation by setting its operands.

```APIDOC
## Struct XOrIOperationBuilder

### Description
A builder for a `xori` operation.

### Methods

#### `new(context: &'c Context, location: Location<'c>) -> Self`
Creates a new `XOrIOperationBuilder` instance.

#### `lhs(self, lhs: Value<'c, '_>) -> XOrIOperationBuilder<'c, Set, O1>`
Sets the left-hand side operand for the `xori` operation.

#### `rhs(self, rhs: Value<'c, '_>) -> XOrIOperationBuilder<'c, Set, Set>`
Sets the right-hand side operand for the `xori` operation.

#### `build(self) -> XOrIOperation<'c>`
Builds and returns the `XOrIOperation` with the specified operands.
```

--------------------------------

### Get Outer Dimensions Permutation Attribute in Rust

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/tensor/struct

Retrieves the optional outer dimensions permutation `Attribute` for the UnPackOperation. This attribute defines how outer dimensions are reordered before unpacking.

```rust
pub fn outer_dims_perm(&self) -> Result<Attribute<'c>, Error>
```

--------------------------------

### MLIR Control Flow Operations (Rust)

Source: https://context7.com/context7/mlir-rs_github_io_melior_melior/llms.txt

Illustrates how to implement control flow using the MLIR 'cf' dialect, specifically demonstrating conditional branching (cond_br) and unconditional branching (br). Requires 'melior' and dialect registration.

```rust
use melior,{
    Context,
    dialect::{DialectRegistry, cf, arith},
    ir::{Block, Location, Module, Region, Type, Value, attribute::IntegerAttribute},
    utility::register_all_dialects,
};

let registry = DialectRegistry::new();
register_all_dialects(&registry);

let context = Context::new();
context.append_dialect_registry(&registry);
context.load_all_available_dialects();

let location = Location::unknown(&context);
let i1_type = Type::integer(&context, 1); // boolean type

// Create blocks for branching
let entry_block = Block::new(&[]);
let then_block = Block::new(&[]);
let else_block = Block::new(&[]);

// Create a condition value (example: constant true)
let condition_op = entry_block.append_operation(arith::constant(
    &context,
    IntegerAttribute::new(i1_type, 1).into(),
    location,
));
let condition = condition_op.result(0).unwrap().into();

// Conditional branch
entry_block.append_operation(cf::cond_br(
    &context,
    condition,
    &then_block,
    &else_block,
    &[], // no arguments to then block
    &[], // no arguments to else block
    location,
));

// Unconditional branch from then_block
then_block.append_operation(cf::br(&else_block, &[], location));
```

--------------------------------

### Rust: LLVM Insert Multiple Values Operation

Source: https://mlir-rs.github.io/melior/melior/helpers/trait

Generates an `llvm.insertvalue` operation to insert multiple elements into an aggregate, starting from a specified index. This is useful for updating parts of an aggregate structure.

```rust
fn insert_values<'block>(
    &'block self,
    context: &'c Context,
    location: Location<'c>,
    container: Value<'c, 'block>,
    values: &[Value<'c, 'block>],
) -> Result<Value<'c, 'block>, Error>
```

--------------------------------

### Rust: Blanket Implementations for Generic Traits

Source: https://mlir-rs.github.io/melior/melior/dialect/llvm/struct

Demonstrates blanket implementations of generic traits like Any, Borrow, BorrowMut, CloneToUninit, From, Into, ToOwned, TryFrom, and TryInto for the LoadStoreOptions struct. These implementations leverage Rust's trait system to provide common functionalities without explicit per-type definitions.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId;
}

impl<T> Borrow<T> for T where T: ?Sized {
    fn borrow(&self) -> &T;
}

impl<T> BorrowMut<T> for T where T: ?Sized {
    fn borrow_mut(&mut self) -> &mut T;
}

impl<T> CloneToUninit for T where T: Clone {
    unsafe fn clone_to_uninit(&self, dest: *mut u8);
}

impl<T> From<T> for T {
    fn from(t: T) -> T;
}

impl<T, U> Into<U> for T where U: From<T> {
    fn into(self) -> U;
}

impl<T> ToOwned for T where T: Clone {
    type Owned = T;
    fn to_owned(&self) -> T;
    fn clone_into(&self, target: &mut T);
}

impl<T, U> TryFrom<U> for T where U: Into<T> {
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>;
}

impl<T, U> TryInto<U> for T where U: TryFrom<T> {
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>;
}
```

--------------------------------

### Rust: Vp2IntersectQIntrOperationBuilder Constructor and Methods

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/x_86_vector/struct

Defines the `Vp2IntersectQIntrOperationBuilder` struct and its associated methods for building AVX-512 `vp2intersect.q.512` operations. It includes methods for setting the context, location, and operands, culminating in the `build` method to create the final operation. This pattern is common for complex operation construction in Rust.

```rust
pub struct Vp2IntersectQIntrOperationBuilder<'c, T0, O0, O1> { /* private fields */ }

impl<'c> Vp2IntersectQIntrOperationBuilder<'c, Unset, Unset, Unset> {
    pub fn new(context: &'c Context, location: Location<'c>) -> Self
}

impl<'c, O0, O1> Vp2IntersectQIntrOperationBuilder<'c, Unset, O0, O1> {
    pub fn res( self, res: Type<'c>, ) -> Vp2IntersectQIntrOperationBuilder<'c, Set, O0, O1>
}

impl<'c, T0, O1> Vp2IntersectQIntrOperationBuilder<'c, T0, Unset, O1> {
    pub fn a( self, a: Value<'c, '_>, ) -> Vp2IntersectQIntrOperationBuilder<'c, T0, Set, O1>
}

impl<'c, T0> Vp2IntersectQIntrOperationBuilder<'c, T0, Set, Unset> {
    pub fn b( self, b: Value<'c, '_>, ) -> Vp2IntersectQIntrOperationBuilder<'c, T0, Set, Set>
}

impl<'c> Vp2IntersectQIntrOperationBuilder<'c, Set, Set, Set> {
    pub fn build(self) -> Vp2IntersectQIntrOperation<'c>
}
```

--------------------------------

### Get Operation Attribute Count in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/trait

This Rust code snippet shows the `attribute_count` method, part of the `OperationLike` trait. It returns the total number of attributes attached to the operation as a `usize`.

```rust
fn attribute_count(&self) -> usize { ... }
```

--------------------------------

### Get Operation Region Count in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/trait

This Rust code snippet shows the `region_count` method, part of the `OperationLike` trait. It returns the total number of regions associated with the operation as a `usize`.

```rust
fn region_count(&self) -> usize { ... }
```

--------------------------------

### Get Operation Result Count in Rust

Source: https://mlir-rs.github.io/melior/melior/ir/operation/trait

This Rust code snippet shows the `result_count` method, part of the `OperationLike` trait. It returns the total number of results produced by the operation as a `usize`.

```rust
fn result_count(&self) -> usize { ... }
```

--------------------------------

### Rust Builder Method: new for AffineYieldOperationBuilder

Source: https://mlir-rs.github.io/melior/melior/dialect/ods/affine/struct

Constructor for AffineYieldOperationBuilder. Takes a context and location as input, initializing the builder in an 'Unset' state, ready for operands to be added.

```rust
pub fn new(context: &'c Context, location: Location<'c>) -> Self
```

--------------------------------

### Navigate MLIR regions and blocks

Source: https://mlir-rs.github.io/melior/melior/ir/block/struct

Facilitates navigation between MLIR blocks and their parent regions. Includes methods to get the parent region of a block and to find the next block within the same region.

```rust
fn parent_region(&self) -> Option<RegionRef<'c, 'a>>
fn next_in_region(&self) -> Option<BlockRef<'c, 'a>>
```
Tokens:
Raw