Regenerate MLIR Bindings

Author: enzyme-ci-bot[bot]

src/mlir/Dialects/Affine.jl

@@ -16,7 +16,7 @@ import ...API
 """
 `apply`
 
-The `affine.apply` operation applies an [affine mapping](https://mlir.llvm.org/docs/Dialects/Affine/#affine-maps)
+The `affine.apply` operation applies an [affine mapping](#affine-maps)
 to a list of SSA values, yielding a single SSA value. The number of
 dimension and symbol arguments to `affine.apply` must be equal to the
 respective number of dimensional and symbolic inputs to the affine mapping;
@@ -151,9 +151,9 @@ shorthand-bound ::= ssa-id | `-`? integer-literal
 
 The `affine.for` operation represents an affine loop nest. It has one region
 containing its body. This region must contain one block that terminates with
-[`affine.yield`](https://mlir.llvm.org/docs/Dialects/Affine/#affineyield-affineaffineyieldop). *Note:* when
+[`affine.yield`](#affineyield-mliraffineyieldop). *Note:* when
 `affine.for` is printed in custom format, the terminator is omitted. The
-block has one argument of [`index`](https://mlir.llvm.org/docs/Dialects/Builtin/#indextype) type that
+block has one argument of [`index`](Builtin.md/#indextype) type that
 represents the induction variable of the loop.
 
 The `affine.for` operation executes its body a number of times iterating
@@ -164,7 +164,7 @@ lower bound but does not include the upper bound.
 
 The lower and upper bounds of a `affine.for` operation are represented as an
 application of an affine mapping to a list of SSA values passed to the map.
-The [same restrictions](https://mlir.llvm.org/docs/Dialects/Affine/#restrictions-on-dimensions-and-symbols) hold for
+The [same restrictions](#restrictions-on-dimensions-and-symbols) hold for
 these SSA values as for all bindings of SSA values to dimensions and
 symbols.
 
@@ -296,9 +296,9 @@ iteration space defined by an integer set (a conjunction of affine
 constraints). A single `affine.if` may end with an optional `else` clause.
 
 The condition of the `affine.if` is represented by an
-[integer set](https://mlir.llvm.org/docs/Dialects/Affine/#integer-sets) (a conjunction of affine constraints),
+[integer set](#integer-sets) (a conjunction of affine constraints),
 and the SSA values bound to the dimensions and symbols in the integer set.
-The [same restrictions](https://mlir.llvm.org/docs/Dialects/Affine/#restrictions-on-dimensions-and-symbols) hold for
+The [same restrictions](#restrictions-on-dimensions-and-symbols) hold for
 these SSA values as for all bindings of SSA values to dimensions and
 symbols.
 
@@ -548,7 +548,7 @@ end
 operation ::= ssa-id `=` `affine.min` affine-map-attribute dim-and-symbol-use-list
 ```
 
-The `affine.min` operation applies an [affine mapping](https://mlir.llvm.org/docs/Dialects/Affine/#affine-expressions)
+The `affine.min` operation applies an [affine mapping](#affine-expressions)
 to a list of SSA values, and returns the minimum value of all result
 expressions. The number of dimension and symbol arguments to `affine.min`
 must be equal to the respective number of dimensional and symbolic inputs to
@@ -791,9 +791,9 @@ end
 `vector_load`
 
 The `affine.vector_load` is the vector counterpart of
-[affine.load](https://mlir.llvm.org/docs/Dialects/Affine/#affineload-affineaffineloadop). It reads a slice from a
-[MemRef](https://mlir.llvm.org/docs/Dialects/Builtin/#memreftype), supplied as its first operand,
-into a [vector](https://mlir.llvm.org/docs/Dialects/Builtin/#vectortype) of the same base elemental type.
+[affine.load](#affineload-mliraffineloadop). It reads a slice from a
+[MemRef](Builtin.md/#memreftype), supplied as its first operand,
+into a [vector](Builtin.md/#vectortype) of the same base elemental type.
 The index for each memref dimension is an affine expression of loop induction
 variables and symbols. These indices determine the start position of the read
 within the memref. The shape of the return vector type determines the shape of
@@ -824,7 +824,7 @@ Example 3: 2-dim f32 vector load.
 TODOs:
 * Add support for strided vector loads.
 * Consider adding a permutation map to permute the slice that is read from memory
-(see [vector.transfer_read](https://mlir.llvm.org/docs/Dialects/Vector/#vectortransfer_read-vectortransferreadop)).
+(see [vector.transfer_read](../Vector/#vectortransfer_read-mlirvectortransferreadop)).
 """
 function vector_load(
     memref::Value, indices::Vector{Value}; result::IR.Type, map, location=Location()
@@ -851,9 +851,9 @@ end
 `vector_store`
 
 The `affine.vector_store` is the vector counterpart of
-[affine.store](https://mlir.llvm.org/docs/Dialects/Affine/#affinestore-affineaffinestoreop). It writes a
-[vector](https://mlir.llvm.org/docs/Dialects/Builtin/#vectortype), supplied as its first operand,
-into a slice within a [MemRef](https://mlir.llvm.org/docs/Dialects/Builtin/#memreftype) of the same base
+[affine.store](#affinestore-mliraffinestoreop). It writes a
+[vector](Builtin.md/#vectortype), supplied as its first operand,
+into a slice within a [MemRef](Builtin.md/#memreftype) of the same base
 elemental type, supplied as its second operand.
 The index for each memref dimension is an affine expression of loop
 induction variables and symbols. These indices determine the start position
@@ -886,7 +886,7 @@ affine.vector_store %v0, %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
 TODOs:
 * Add support for strided vector stores.
 * Consider adding a permutation map to permute the slice that is written to memory
-(see [vector.transfer_write](https://mlir.llvm.org/docs/Dialects/Vector/#vectortransfer_write-vectortransferwriteop)).
+(see [vector.transfer_write](../Vector/#vectortransfer_write-mlirvectortransferwriteop)).
 """
 function vector_store(
     value::Value, memref::Value, indices::Vector{Value}; map, location=Location()

src/mlir/Dialects/Arith.jl

@@ -219,7 +219,7 @@ value of equal bit width. When operating on vectors, casts elementwise.
 
 Note that this implements a logical bitcast independent of target
 endianness. This allows constant folding without target information and is
-consistent with the bitcast constant folders in LLVM (see
+consitent with the bitcast constant folders in LLVM (see
 https://github.com/llvm/llvm-project/blob/18c19414eb/llvm/lib/IR/ConstantFold.cpp#L168)
 For targets where the source and target type have the same endianness (which
 is the standard), this cast will also change no bits at runtime, but it may
@@ -253,7 +253,7 @@ end
 
 Signed integer division. Rounds towards positive infinity, i.e. `7 / -2 = -3`.
 
-Division by zero, or signed division overflow (minimum value divided by -1) 
+Divison by zero, or signed division overflow (minimum value divided by -1) 
 is undefined behavior. When applied to `vector` and `tensor` values, the 
 behavior is undefined if _any_ of its elements are divided by zero or has a 
 signed division overflow.
@@ -419,16 +419,16 @@ main reason being that comparison operations have diverging sets of
 attributes: integers require sign specification while floats require various
 floating point-related particularities, e.g., `-ffast-math` behavior,
 IEEE754 compliance, etc
-([rationale](https://mlir.llvm.org/docs/Rationale/Rationale/#splitting-floating-point-vs-integer-operations)).
+([rationale](../Rationale/Rationale.md#splitting-floating-point-vs-integer-operations)).
 The type of comparison is specified as attribute to avoid introducing ten
 similar operations, taking into account that they are often implemented
 using the same operation downstream
-([rationale](https://mlir.llvm.org/docs/Rationale/Rationale/#specifying-comparison-kind-as-attribute)). The
+([rationale](../Rationale/Rationale.md#specifying-comparison-kind-as-attribute)). The
 separation between signed and unsigned order comparisons is necessary
 because of integers being signless. The comparison operation must know how
 to interpret values with the foremost bit being set: negatives in two\'s
 complement or large positives
-([rationale](https://mlir.llvm.org/docs/Rationale/Rationale/#specifying-sign-in-integer-comparison-operations)).
+([rationale](../Rationale/Rationale.md#specifying-sign-in-integer-comparison-operations)).
 
 # Example
 

src/mlir/Dialects/Builtin.jl

@@ -17,11 +17,11 @@ import ...API
 `module_`
 
 A `module` represents a top-level container operation. It contains a single
-[graph region](https://mlir.llvm.org/docs/LangRef/#control-flow-and-ssacfg-regions) containing a single block
+[graph region](../LangRef.md#control-flow-and-ssacfg-regions) containing a single block
 which can contain any operations and does not have a terminator. Operations
 within this region cannot implicitly capture values defined outside the module,
-i.e. Modules are [IsolatedFromAbove](https://mlir.llvm.org/docs/Traits/#isolatedfromabove). Modules have
-an optional [symbol name](https://mlir.llvm.org/docs/SymbolsAndSymbolTables/) which can be used to refer
+i.e. Modules are [IsolatedFromAbove](../Traits.md#isolatedfromabove). Modules have
+an optional [symbol name](../SymbolsAndSymbolTables.md) which can be used to refer
 to them in operations.
 
 # Example

src/mlir/Dialects/Func.jl

@@ -121,7 +121,7 @@ to a `func.func` operation
 MLIR does not allow direct references to functions in SSA operands because
 the compiler is multithreaded, and disallowing SSA values to directly
 reference a function simplifies this
-([rationale](https://mlir.llvm.org/docs/Rationale/Rationale/#multithreading-the-compiler)).
+([rationale](../Rationale/Rationale.md#multithreading-the-compiler)).
 """
 function constant(; result_0::IR.Type, value, location=Location())
     op_ty_results = IR.Type[result_0,]

src/mlir/Dialects/MemRef.jl

@@ -206,7 +206,7 @@ element type of the memref.
 
 A set `nontemporal` attribute indicates that this load is not expected to
 be reused in the cache. For details, refer to the
-[LLVM load instruction](https://llvm.org/docs/LangRef.html#load-instruction).
+[https://llvm.org/docs/LangRef.html#load-instruction](LLVM load instruction).
 
 # Example
 
@@ -315,7 +315,7 @@ end
 The `alloca` operation allocates memory on the stack, to be automatically
 released when control transfers back from the region of its closest
 surrounding operation with an
-[`AutomaticAllocationScope`](https://mlir.llvm.org/docs/Traits/#automaticallocationscope) trait.
+[`AutomaticAllocationScope`](../Traits.md/#automaticallocationscope) trait.
 The amount of memory allocated is specified by its memref and additional
 operands. For example:
 
@@ -1238,7 +1238,7 @@ memref.
 ```
 
 If the result memref has a dynamic shape, a result dimension operand is
-needed to specify its dynamic dimension. In the example below, the ssa value
+needed to spefify its dynamic dimension. In the example below, the ssa value
 \'%d\' specifies the unknown dimension of the result memref.
 
 ```mlir
@@ -1431,7 +1431,7 @@ be in-bounds: `0 <= idx < dim_size`
 
 A set `nontemporal` attribute indicates that this store is not expected to
 be reused in the cache. For details, refer to the
-[LLVM store instruction](https://llvm.org/docs/LangRef.html#store-instruction).
+[https://llvm.org/docs/LangRef.html#store-instruction](LLVM store instruction).
 
 # Example
 

src/mlir/libMLIR_h.jl

@@ -260,9 +260,6 @@ struct MlirDialectRegistry
     ptr::Ptr{Cvoid}
 end
 
-"""
-    MlirOperation
-"""
 struct MlirOperation
     ptr::Ptr{Cvoid}
 end
@@ -287,9 +284,6 @@ struct MlirSymbolTable
     ptr::Ptr{Cvoid}
 end
 
-"""
-    MlirAttribute
-"""
 struct MlirAttribute
     ptr::Ptr{Cvoid}
 end
@@ -298,10 +292,6 @@ struct MlirIdentifier
     ptr::Ptr{Cvoid}
 end
 
-"""
-    MlirLocation
-A location in MLIR.
-"""
 struct MlirLocation
     ptr::Ptr{Cvoid}
 end
@@ -310,10 +300,6 @@ struct MlirModule
     ptr::Ptr{Cvoid}
 end
 
-"""
-    MlirType
-A type in MLIR.
-"""
 struct MlirType
     ptr::Ptr{Cvoid}
 end
@@ -3372,7 +3358,7 @@ end
 """
     mlirIntegerSetIsCanonicalEmpty(set)
 
-Checks whether the given set is a canonical empty set, e.g., the set returned by [`Reactant.MLIR.API.mlirIntegerSetEmptyGet`](@ref).
+Checks whether the given set is a canonical empty set, e.g., the set returned by [`mlirIntegerSetEmptyGet`](@ref).
 """
 function mlirIntegerSetIsCanonicalEmpty(set)
     @ccall mlir_c.mlirIntegerSetIsCanonicalEmpty(set::MlirIntegerSet)::Bool
@@ -5727,7 +5713,7 @@ end
 """
     mlirRankedTensorTypeGet(rank, shape, elementType, encoding)
 
-Creates a tensor type of a fixed rank with the given shape, element type, and optional encoding in the same context as the element type. The type is owned by the context. Tensor types without any specific encoding field should assign [`Reactant.MLIR.API.mlirAttributeGetNull`](@ref)() to this parameter.
+Creates a tensor type of a fixed rank with the given shape, element type, and optional encoding in the same context as the element type. The type is owned by the context. Tensor types without any specific encoding field should assign [`mlirAttributeGetNull`](@ref)() to this parameter.
 """
 function mlirRankedTensorTypeGet(rank, shape, elementType, encoding)
     @ccall mlir_c.mlirRankedTensorTypeGet(
@@ -8507,9 +8493,6 @@ function mlirInferShapedTypeOpInterfaceInferReturnTypes(
     )::MlirLogicalResult
 end
 
-"""
-    MlirPass
-"""
 struct MlirPass
     ptr::Ptr{Cvoid}
 end
@@ -10618,7 +10601,4 @@ function sdyManualAxesAttrGetAxesElem(attr, pos)
     )::MlirStringRef
 end
 
-"""
-    MLIR_CAPI_DWARF_ADDRESS_SPACE_NULL
-"""
 const MLIR_CAPI_DWARF_ADDRESS_SPACE_NULL = -1