Regenerate MLIR Bindings (#1084)

Co-authored-by: enzyme-ci-bot[bot] <78882869+enzyme-ci-bot[bot]@users.noreply.github.com>

Author: github-actions[bot]

src/mlir/Dialects/Llvm.jl

@@ -726,6 +726,45 @@ function mlir_constant(; res::IR.Type, value, location=Location())
     )
 end
 
+"""
+`dso_local_equivalent`
+
+Creates an SSA value containing a pointer to a global value (function or
+alias to function). It represents a function which is functionally
+equivalent to a given function, but is always defined in the current
+linkage unit. The target function may not have `extern_weak` linkage.
+
+Examples:
+
+```mlir
+llvm.mlir.global external constant @const() : i64 {
+  %0 = llvm.mlir.addressof @const : !llvm.ptr
+  %1 = llvm.ptrtoint %0 : !llvm.ptr to i64
+  %2 = llvm.dso_local_equivalent @func : !llvm.ptr
+  %4 = llvm.ptrtoint %2 : !llvm.ptr to i64
+  llvm.return %4 : i64
+}
+```
+"""
+function dso_local_equivalent(; res::IR.Type, function_name, location=Location())
+    op_ty_results = IR.Type[res,]
+    operands = Value[]
+    owned_regions = Region[]
+    successors = Block[]
+    attributes = NamedAttribute[namedattribute("function_name", function_name),]
+
+    return create_operation(
+        "llvm.dso_local_equivalent",
+        location;
+        operands,
+        owned_regions,
+        successors,
+        attributes,
+        results=op_ty_results,
+        result_inference=false,
+    )
+end
+
 function extractelement(
     vector::Value, position::Value; res=nothing::Union{Nothing,IR.Type}, location=Location()
 )

src/mlir/Dialects/Nvvm.jl

@@ -304,6 +304,37 @@ function breakpoint(; location=Location())
     )
 end
 
+"""
+`st_bulk`
+
+Initializes a region of shared memory at the address given by `addr`.
+The `size` operand specifies the number of bytes to initialize and must be 
+a multiple of 8.
+The `initVal` operand specifies the value to initialize the memory to. The 
+only supported value is 0.
+
+[For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#data-movement-and-conversion-instructions-st-bulk)
+"""
+function st_bulk(addr::Value, size::Value; initVal=nothing, location=Location())
+    op_ty_results = IR.Type[]
+    operands = Value[addr, size]
+    owned_regions = Region[]
+    successors = Block[]
+    attributes = NamedAttribute[]
+    !isnothing(initVal) && push!(attributes, namedattribute("initVal", initVal))
+
+    return create_operation(
+        "nvvm.st.bulk",
+        location;
+        operands,
+        owned_regions,
+        successors,
+        attributes,
+        results=op_ty_results,
+        result_inference=false,
+    )
+end
+
 function read_ptx_sreg_clock64(; res::IR.Type, location=Location())
     op_ty_results = IR.Type[res,]
     operands = Value[]

src/mlir/Dialects/Triton.jl

@@ -28,13 +28,20 @@ symbol reference attribute named \"callee\".
 ```
 """
 function call(
-    operands::Vector{Value}; result_0::Vector{IR.Type}, callee, location=Location()
+    operands::Vector{Value};
+    result_0::Vector{IR.Type},
+    callee,
+    arg_attrs=nothing,
+    res_attrs=nothing,
+    location=Location(),
 )
     op_ty_results = IR.Type[result_0...,]
     operands = Value[operands...,]
     owned_regions = Region[]
     successors = Block[]
     attributes = NamedAttribute[namedattribute("callee", callee),]
+    !isnothing(arg_attrs) && push!(attributes, namedattribute("arg_attrs", arg_attrs))
+    !isnothing(res_attrs) && push!(attributes, namedattribute("res_attrs", res_attrs))
 
     return create_operation(
         "tt.call",
@@ -459,39 +466,39 @@ end
 """
 `dot_scaled`
 
-\$d = matrix_multiply(scale(\$lhs, \$lhs_scale), scale(rlhs, \$rhs_scale)) + \$c.
+\$d = matrix_multiply(scale(\$a, \$a_scale), scale(\$b, \$b_scale)) + \$c.
 Where scale(x, s) is a function that applies the scale per block following microscaling spec.
 """
 function dot_scaled(
-    lhs::Value,
-    rhs::Value,
+    a::Value,
+    b::Value,
     c::Value,
-    lhs_scale=nothing::Union{Nothing,Value};
-    rhs_scale=nothing::Union{Nothing,Value},
+    a_scale=nothing::Union{Nothing,Value};
+    b_scale=nothing::Union{Nothing,Value},
     d::IR.Type,
-    lhs_type,
-    rhs_type,
+    a_elem_type,
+    b_elem_type,
     fastMath,
     location=Location(),
 )
     op_ty_results = IR.Type[d,]
-    operands = Value[lhs, rhs, c]
+    operands = Value[a, b, c]
     owned_regions = Region[]
     successors = Block[]
     attributes = NamedAttribute[
-        namedattribute("lhs_type", lhs_type),
-        namedattribute("rhs_type", rhs_type),
+        namedattribute("a_elem_type", a_elem_type),
+        namedattribute("b_elem_type", b_elem_type),
         namedattribute("fastMath", fastMath),
     ]
-    !isnothing(lhs_scale) && push!(operands, lhs_scale)
-    !isnothing(rhs_scale) && push!(operands, rhs_scale)
+    !isnothing(a_scale) && push!(operands, a_scale)
+    !isnothing(b_scale) && push!(operands, b_scale)
     push!(attributes, operandsegmentsizes([
         1,
         1,
         1,
-        if (lhs_scale == nothing)
+        if (a_scale == nothing)
             0
-        elseif 1(rhs_scale == nothing)
+        elseif 1(b_scale == nothing)
             0
         else
             1
@@ -973,15 +980,12 @@ shape 4x8x2xf32.
 Because Triton tensors always have a power-of-two number of elements,
 the two input tensors must have the same shape.
 """
-function join(
-    lhs::Value, rhs::Value; result=nothing::Union{Nothing,IR.Type}, location=Location()
-)
-    op_ty_results = IR.Type[]
+function join(lhs::Value, rhs::Value; result::IR.Type, location=Location())
+    op_ty_results = IR.Type[result,]
     operands = Value[lhs, rhs]
     owned_regions = Region[]
     successors = Block[]
     attributes = NamedAttribute[]
-    !isnothing(result) && push!(op_ty_results, result)
 
     return create_operation(
         "tt.join",
@@ -990,8 +994,8 @@ function join(
         owned_regions,
         successors,
         attributes,
-        results=(length(op_ty_results) == 0 ? nothing : op_ty_results),
-        result_inference=(length(op_ty_results) == 0 ? true : false),
+        results=op_ty_results,
+        result_inference=false,
     )
 end
 

src/mlir/libMLIR_h.jl

@@ -7775,6 +7775,101 @@ function mlirUniformQuantizedPerAxisTypeIsFixedPoint(type)
     @ccall mlir_c.mlirUniformQuantizedPerAxisTypeIsFixedPoint(type::MlirType)::Bool
 end
 
+"""
+    mlirTypeIsAUniformQuantizedSubChannelType(type)
+
+Returns `true` if the given type is a UniformQuantizedSubChannel.
+"""
+function mlirTypeIsAUniformQuantizedSubChannelType(type)
+    @ccall mlir_c.mlirTypeIsAUniformQuantizedSubChannelType(type::MlirType)::Bool
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGet(flags, storageType, expressedType, scalesAttr, zeroPointsAttr, blockSizeInfoLength, quantizedDimensions, blockSizes, storageTypeMin, storageTypeMax)
+
+Creates a UniformQuantizedSubChannelType with the given parameters.
+
+The type is owned by the context. `scalesAttr` and `zeroPointsAttr` must be DenseElementsAttrs. `quantizedDimensions` and `blockSizes` point to `blockSizeInfoLength` number of elements, describing respectively the quantization axis and corresponding block size.
+"""
+function mlirUniformQuantizedSubChannelTypeGet(
+    flags,
+    storageType,
+    expressedType,
+    scalesAttr,
+    zeroPointsAttr,
+    blockSizeInfoLength,
+    quantizedDimensions,
+    blockSizes,
+    storageTypeMin,
+    storageTypeMax,
+)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGet(
+        flags::Cuint,
+        storageType::MlirType,
+        expressedType::MlirType,
+        scalesAttr::MlirAttribute,
+        zeroPointsAttr::MlirAttribute,
+        blockSizeInfoLength::intptr_t,
+        quantizedDimensions::Ptr{Int32},
+        blockSizes::Ptr{Int64},
+        storageTypeMin::Int64,
+        storageTypeMax::Int64,
+    )::MlirType
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(type)
+
+Returns the number of block sizes provided in type.
+"""
+function mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(type)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(
+        type::MlirType
+    )::intptr_t
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(type, pos)
+
+Returns the quantized dimension at the given position.
+"""
+function mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(type, pos)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(
+        type::MlirType, pos::intptr_t
+    )::Int32
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGetBlockSize(type, pos)
+
+Returns the block size at the given position.
+"""
+function mlirUniformQuantizedSubChannelTypeGetBlockSize(type, pos)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGetBlockSize(
+        type::MlirType, pos::intptr_t
+    )::Int64
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGetScales(type)
+
+Returns the scales of the quantized type.
+"""
+function mlirUniformQuantizedSubChannelTypeGetScales(type)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGetScales(type::MlirType)::MlirAttribute
+end
+
+"""
+    mlirUniformQuantizedSubChannelTypeGetZeroPoints(type)
+
+Returns the zero-points of the quantized type.
+"""
+function mlirUniformQuantizedSubChannelTypeGetZeroPoints(type)
+    @ccall mlir_c.mlirUniformQuantizedSubChannelTypeGetZeroPoints(
+        type::MlirType
+    )::MlirAttribute
+end
+
 """
     mlirTypeIsACalibratedQuantizedType(type)
 
@@ -10369,6 +10464,8 @@ function sdyOpShardingRuleAttrGet(
     needReplicationFactors,
     nPermutationFactors,
     permutationFactors,
+    nBlockedPropagationFactors,
+    blockedPropagationFactors,
     isCustomRule,
 )
     @ccall mlir_c.sdyOpShardingRuleAttrGet(
@@ -10385,6 +10482,8 @@ function sdyOpShardingRuleAttrGet(
         needReplicationFactors::Ptr{Int64},
         nPermutationFactors::intptr_t,
         permutationFactors::Ptr{Int64},
+        nBlockedPropagationFactors::Int64,
+        blockedPropagationFactors::Ptr{Int64},
         isCustomRule::Bool,
     )::MlirAttribute
 end
@@ -10459,6 +10558,18 @@ function sdyOpShardingRuleAttrGetPermutationFactorsElem(attr, pos)
     )::Int64
 end
 
+function sdyOpShardingRuleAttrGetBlockedPropagationFactorsSize(attr)
+    @ccall mlir_c.sdyOpShardingRuleAttrGetBlockedPropagationFactorsSize(
+        attr::MlirAttribute
+    )::intptr_t
+end
+
+function sdyOpShardingRuleAttrGetBlockedPropagationFactorsElem(attr, pos)
+    @ccall mlir_c.sdyOpShardingRuleAttrGetBlockedPropagationFactorsElem(
+        attr::MlirAttribute, pos::intptr_t
+    )::Int64
+end
+
 function sdyAttributeIsAManualAxesAttr(attr)
     @ccall mlir_c.sdyAttributeIsAManualAxesAttr(attr::MlirAttribute)::Bool
 end