[mlir] Add DenseUI32ArrayAttr

[mamrami]

oops
will move it to github

[mamrami]

Uploaded the change to github https://github.com/llvm/llvm-project/pull/68230

mlir/include/mlir/IR/Builders.h

public:
   DenseIntElementsAttr getI32TensorAttr(ArrayRef<int32_t> values);
   DenseIntElementsAttr getI64TensorAttr(ArrayRef<int64_t> values);
   DenseIntElementsAttr getIndexTensorAttr(ArrayRef<int64_t> values);
 
   /// Tensor-typed DenseArrayAttr getters.
   DenseBoolArrayAttr getDenseBoolArrayAttr(ArrayRef<bool> values);
   DenseI8ArrayAttr getDenseI8ArrayAttr(ArrayRef<int8_t> values);
   DenseI16ArrayAttr getDenseI16ArrayAttr(ArrayRef<int16_t> values);
+  DenseUI32ArrayAttr getDenseUI32ArrayAttr(ArrayRef<uint32_t> values);
   DenseI32ArrayAttr getDenseI32ArrayAttr(ArrayRef<int32_t> values);
   DenseI64ArrayAttr getDenseI64ArrayAttr(ArrayRef<int64_t> values);
   DenseF32ArrayAttr getDenseF32ArrayAttr(ArrayRef<float> values);
   DenseF64ArrayAttr getDenseF64ArrayAttr(ArrayRef<double> values);
 
   ArrayAttr getAffineMapArrayAttr(ArrayRef<AffineMap> values);
   ArrayAttr getBoolArrayAttr(ArrayRef<bool> values);
   ArrayAttr getI32ArrayAttr(ArrayRef<int32_t> values);

mlir/include/mlir/IR/BuiltinAttributes.h

public:
 
   /// Support for isa<>/cast<>.
   static bool classof(Attribute attr);
 };
 
 extern template class DenseArrayAttrImpl<bool>;
 extern template class DenseArrayAttrImpl<int8_t>;
 extern template class DenseArrayAttrImpl<int16_t>;
+extern template class DenseArrayAttrImpl<uint32_t>;
 extern template class DenseArrayAttrImpl<int32_t>;
 extern template class DenseArrayAttrImpl<int64_t>;
 extern template class DenseArrayAttrImpl<float>;
 extern template class DenseArrayAttrImpl<double>;
 } // namespace detail
 
 // Public name for all the supported DenseArrayAttr
 using DenseBoolArrayAttr = detail::DenseArrayAttrImpl<bool>;
 using DenseI8ArrayAttr = detail::DenseArrayAttrImpl<int8_t>;
 using DenseI16ArrayAttr = detail::DenseArrayAttrImpl<int16_t>;
+using DenseUI32ArrayAttr = detail::DenseArrayAttrImpl<uint32_t>;
 using DenseI32ArrayAttr = detail::DenseArrayAttrImpl<int32_t>;
 using DenseI64ArrayAttr = detail::DenseArrayAttrImpl<int64_t>;
 using DenseF32ArrayAttr = detail::DenseArrayAttrImpl<float>;
 using DenseF64ArrayAttr = detail::DenseArrayAttrImpl<double>;
 
 //===----------------------------------------------------------------------===//
 // DenseResourceElementsAttr
 

mlir/include/mlir/IR/CommonAttrConstraints.td

ElementsAttrBase<CPred<"::llvm::isa<::mlir::" # denseAttrName # ">($_self)">,
                      summaryName # " dense array attribute"> {
   let storageType = "::mlir::" # denseAttrName;
   let returnType = "::llvm::ArrayRef<" # cppType # ">";
   let constBuilderCall = "$_builder.get" # denseAttrName # "($0)";
 }
 def DenseBoolArrayAttr : DenseArrayAttrBase<"DenseBoolArrayAttr", "bool", "i1">;
 def DenseI8ArrayAttr : DenseArrayAttrBase<"DenseI8ArrayAttr", "int8_t", "i8">;
 def DenseI16ArrayAttr : DenseArrayAttrBase<"DenseI16ArrayAttr", "int16_t", "i16">;
+def DenseUI32ArrayAttr : DenseArrayAttrBase<"DenseUI32ArrayAttr", "uint32_t", "ui32">;
 def DenseI32ArrayAttr : DenseArrayAttrBase<"DenseI32ArrayAttr", "int32_t", "i32">;
 def DenseI64ArrayAttr : DenseArrayAttrBase<"DenseI64ArrayAttr", "int64_t", "i64">;
 def DenseF32ArrayAttr : DenseArrayAttrBase<"DenseF32ArrayAttr", "float", "f32">;
 def DenseF64ArrayAttr : DenseArrayAttrBase<"DenseF64ArrayAttr", "double", "f64">;
 
 def IndexElementsAttr
     : IntElementsAttrBase<CPred<[{::llvm::cast<::mlir::DenseIntElementsAttr>($_self)
                                       .getType()

mlir/lib/IR/Builders.cpp

 DenseI16ArrayAttr Builder::getDenseI16ArrayAttr(ArrayRef<int16_t> values) {
   return DenseI16ArrayAttr::get(context, values);
 }
 
 DenseI32ArrayAttr Builder::getDenseI32ArrayAttr(ArrayRef<int32_t> values) {
   return DenseI32ArrayAttr::get(context, values);
 }
 
+DenseUI32ArrayAttr Builder::getDenseUI32ArrayAttr(ArrayRef<uint32_t> values) {
+  return DenseUI32ArrayAttr::get(context, values);
+}
+
 DenseI64ArrayAttr Builder::getDenseI64ArrayAttr(ArrayRef<int64_t> values) {
   return DenseI64ArrayAttr::get(context, values);
 }
 
 DenseF32ArrayAttr Builder::getDenseF32ArrayAttr(ArrayRef<float> values) {
   return DenseF32ArrayAttr::get(context, values);
 }
 

mlir/lib/IR/BuiltinAttributes.cpp

 struct DenseArrayAttrUtil<int8_t> : public DenseArrayAttrIntUtil<8> {
   static void printElement(raw_ostream &os, int8_t value) {
     os << static_cast<int>(value);
   }
 };
 template <>
 struct DenseArrayAttrUtil<int16_t> : public DenseArrayAttrIntUtil<16> {};
 template <>
+struct DenseArrayAttrUtil<uint32_t>
+    : public DenseArrayAttrIntUtil<32, IntegerType::Unsigned> {};
+template <>
 struct DenseArrayAttrUtil<int32_t> : public DenseArrayAttrIntUtil<32> {};
 template <>
 struct DenseArrayAttrUtil<int64_t> : public DenseArrayAttrIntUtil<64> {};
 
 /// Specialization for 32-bit floats.
 template <>
 struct DenseArrayAttrUtil<float> {
   static bool checkElementType(Type eltType) { return eltType.isF32(); }

 }
 
 namespace mlir {
 namespace detail {
 // Explicit instantiation for all the supported DenseArrayAttr.
 template class DenseArrayAttrImpl<bool>;
 template class DenseArrayAttrImpl<int8_t>;
 template class DenseArrayAttrImpl<int16_t>;
+template class DenseArrayAttrImpl<uint32_t>;
 template class DenseArrayAttrImpl<int32_t>;
 template class DenseArrayAttrImpl<int64_t>;
 template class DenseArrayAttrImpl<float>;
 template class DenseArrayAttrImpl<double>;
 } // namespace detail
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//

mlir/test/IR/attribute.mlir

 // CHECK-SAME: emptyi1attr = array<i1>,
                emptyi1attr = array<i1>,
 // CHECK-SAME: emptyi32attr = array<i32>,
                emptyi32attr = array<i32>,
 // CHECK-SAME: emptyi64attr = array<i64>,
                emptyi64attr = array<i64>,
 // CHECK-SAME: emptyi8attr = array<i8>,
                emptyi8attr = array<i8>,
+// CHECK-SAME: emptyui32attr = array<ui32>,
+               emptyui32attr = array<ui32>,
 // CHECK-SAME: f32attr = array<f32: 1.024000e+03, 4.530000e+02, -6.435000e+03>,
                f32attr = array<f32: 1024., 453., -6435.>,
 // CHECK-SAME: f64attr = array<f64: -1.420000e+02>,
                f64attr = array<f64: -142.>,
 // CHECK-SAME: i16attr = array<i16: 3, 5, -4, 10>,
                i16attr = array<i16: 3, 5, -4, 10>,
 // CHECK-SAME: i1attr = array<i1: true, false, true>,
                i1attr = array<i1: true, false, true>,
 // CHECK-SAME: i32attr = array<i32: 1024, 453, -6435>,
                i32attr = array<i32: 1024, 453, -6435>,
 // CHECK-SAME: i64attr = array<i64: -142>,
                i64attr = array<i64: -142>,
 // CHECK-SAME: i8attr = array<i8: 1, -2, 3>
-               i8attr = array<i8: 1, -2, 3>
+               i8attr = array<i8: 1, -2, 3>,
+// CHECK-SAME: ui32attr = array<ui32: 1024, 453, 6435>
+               ui32attr = array<ui32: 1024, 453, 6435>
  } {
 // CHECK:  test.dense_array_attr
   test.dense_array_attr
 // CHECK-SAME: i1attr = [true, false, true]
                i1attr = [true, false, true]
 // CHECK-SAME: i8attr = [1, -2, 3]
                i8attr = [1, -2, 3]
 // CHECK-SAME: i16attr = [3, 5, -4, 10]
                i16attr = [3, 5, -4, 10]
 // CHECK-SAME: i32attr = [1024, 453, -6435]
                i32attr = [1024, 453, -6435]
+// CHECK-SAME: ui32attr = [1024, 453, 6435]
+               ui32attr = [1024, 453, 6435]
 // CHECK-SAME: i64attr = [-142]
                i64attr = [-142]
 // CHECK-SAME: f32attr = [1.024000e+03, 4.530000e+02, -6.435000e+03]
                f32attr = [1024., 453., -6435.]
 // CHECK-SAME: f64attr = [-1.420000e+02]
                f64attr = [-142.]
 // CHECK-SAME: emptyattr = []
                emptyattr = []

 }
 
 // -----
 
 func.func @testConfinedDenseArrayAttr() {
   "test.confined_dense_array_attr"() {
     i64attr = array<i64: 0, 2, 3>,
     i32attr = array<i32: 1>,
+    ui32attr = array<ui32: 10>,
     emptyattr = array<i16>
   } : () -> ()
   func.return
 }
 
 // -----
 
 func.func @testConfinedDenseArrayAttrDuplicateValues() {
   // expected-error@+1{{'test.confined_dense_array_attr' op attribute 'i64attr' failed to satisfy constraint: i64 dense array attribute should be in increasing order}}
   "test.confined_dense_array_attr"() {
     emptyattr = array<i16>,
+    ui32attr = array<ui32: 3, 3>,
     i32attr = array<i32: 1, 1>,
     i64attr = array<i64: 0, 2, 2>
   } : () -> ()
   func.return
 }
 
 // -----
 
 func.func @testConfinedDenseArrayAttrDecreasingOrder() {
   // expected-error@+1{{'test.confined_dense_array_attr' op attribute 'i32attr' failed to satisfy constraint: i32 dense array attribute should be in non-decreasing order}}
   "test.confined_dense_array_attr"() {
     emptyattr = array<i16>,
+    ui32attr = array<ui32: 1, 2>,
     i32attr = array<i32: 1, 0>,
     i64attr = array<i64: 0, 2, 3>
   } : () -> ()
   func.return
 }
 
 // -----
 
 func.func @testConfinedStrictlyPositiveDenseArrayAttr() {
   "test.confined_strictly_positive_attr"() {
     i8attr = array<i8: 2, 3>,
     i16attr = array<i16: 20, 30>,
+    ui32attr = array<ui32: 1>,
     i32attr = array<i32: 1>,
     i64attr = array<i64: 1, 2, 3>,
     f32attr = array<f32: 1.1, 2.1>,
     f64attr = array<f64: 2.1, 3.1>,
     emptyattr = array<i16>
   } : () -> ()
   func.return
 }
 
 // -----
 
 func.func @testConfinedStrictlyPositiveDenseArrayAttr() {
   // expected-error@+1{{'test.confined_strictly_positive_attr' op attribute 'i64attr' failed to satisfy constraint: i64 dense array attribute whose value is positive}}
   "test.confined_strictly_positive_attr"() {
     i8attr = array<i8: 2, 3>,
     i16attr = array<i16: 20, 30>,
+    ui32attr = array<ui32: 1>,
     i32attr = array<i32: 1>,
     i64attr = array<i64: 0, 2, 3>,
     f32attr = array<f32: 1.1, 2.1>,
     f64attr = array<f64: 2.1, 3.1>,
     emptyattr = array<i16>
   } : () -> ()
   func.return
 }

mlir/test/lib/Dialect/Test/TestOps.td

 }
 
 def DenseArrayAttrOp : TEST_Op<"dense_array_attr"> {
   let arguments = (ins
     DenseBoolArrayAttr:$i1attr,
     DenseI8ArrayAttr:$i8attr,
     DenseI16ArrayAttr:$i16attr,
     DenseI32ArrayAttr:$i32attr,
+    DenseUI32ArrayAttr:$ui32attr,
     DenseI64ArrayAttr:$i64attr,
     DenseF32ArrayAttr:$f32attr,
     DenseF64ArrayAttr:$f64attr,
     DenseI32ArrayAttr:$emptyattr
   );
   let assemblyFormat = [{
    `i1attr` `=` $i1attr `i8attr` `=` $i8attr `i16attr` `=` $i16attr
-   `i32attr` `=` $i32attr `i64attr` `=` $i64attr  `f32attr` `=` $f32attr
+   `i32attr` `=` $i32attr `ui32attr` `=` $ui32attr `i64attr` `=` $i64attr  `f32attr` `=` $f32attr
    `f64attr` `=` $f64attr `emptyattr` `=` $emptyattr attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test Attributes Constraints
 //===----------------------------------------------------------------------===//
 
 def ConfinedDenseArrayAttrOp : TEST_Op<"confined_dense_array_attr"> {
   let arguments = (ins
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayStrictlySorted<DenseI16ArrayAttr>]>:$emptyattr,
+      ConfinedAttr<DenseUI32ArrayAttr,
+                   [DenseArraySorted<DenseUI32ArrayAttr>]>:$ui32attr,
       ConfinedAttr<DenseI32ArrayAttr,
                    [DenseArraySorted<DenseI32ArrayAttr>]>:$i32attr,
       ConfinedAttr<DenseI64ArrayAttr,
                    [DenseArrayStrictlySorted<DenseI64ArrayAttr>]>:$i64attr
   );
 }
 
 // It does not make sense to have this constraint on a DenseBoolArrayAttr.
 def DenseArrayStrictlyPositiveAttrOp : TEST_Op<"confined_strictly_positive_attr"> {
   let arguments = (ins
       ConfinedAttr<DenseI8ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI8ArrayAttr>]>:$i8attr,
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI16ArrayAttr>]>:$i16attr,
+      ConfinedAttr<DenseUI32ArrayAttr,
+                   [DenseArrayStrictlyPositive<DenseUI32ArrayAttr>]>:$ui32attr,
       ConfinedAttr<DenseI32ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI32ArrayAttr>]>:$i32attr,
       ConfinedAttr<DenseI64ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI64ArrayAttr>]>:$i64attr,
       ConfinedAttr<DenseF32ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseF32ArrayAttr>]>:$f32attr,
       ConfinedAttr<DenseF64ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseF64ArrayAttr>]>:$f64attr,
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI16ArrayAttr>]>:$emptyattr
   );
 }
 
-// It does not make sense to have this constraint on a DenseBoolArrayAttr.
+// It does not make sense to have this constraint on a DenseBoolArrayAttr/DenseUI32ArrayAttr.
 // It is always true.
 def DenseArrayNonNegativeOp : TEST_Op<"confined_non_negative_attr"> {
   let arguments = (ins
       ConfinedAttr<DenseI8ArrayAttr,
                    [DenseArrayNonNegative<DenseI8ArrayAttr>]>:$i8attr,
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayNonNegative<DenseI16ArrayAttr>]>:$i16attr,
       ConfinedAttr<DenseI32ArrayAttr,