diff --git a/mlir/include/mlir/IR/Builders.h b/mlir/include/mlir/IR/Builders.h
--- a/mlir/include/mlir/IR/Builders.h
+++ b/mlir/include/mlir/IR/Builders.h
@@ -154,6 +154,7 @@
   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);
diff --git a/mlir/include/mlir/IR/BuiltinAttributes.h b/mlir/include/mlir/IR/BuiltinAttributes.h
--- a/mlir/include/mlir/IR/BuiltinAttributes.h
+++ b/mlir/include/mlir/IR/BuiltinAttributes.h
@@ -755,6 +755,7 @@
 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>;
@@ -765,6 +766,7 @@
 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>;
diff --git a/mlir/include/mlir/IR/CommonAttrConstraints.td b/mlir/include/mlir/IR/CommonAttrConstraints.td
--- a/mlir/include/mlir/IR/CommonAttrConstraints.td
+++ b/mlir/include/mlir/IR/CommonAttrConstraints.td
@@ -433,6 +433,7 @@
 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">;
diff --git a/mlir/lib/IR/Builders.cpp b/mlir/lib/IR/Builders.cpp
--- a/mlir/lib/IR/Builders.cpp
+++ b/mlir/lib/IR/Builders.cpp
@@ -180,6 +180,10 @@
   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);
 }
diff --git a/mlir/lib/IR/BuiltinAttributes.cpp b/mlir/lib/IR/BuiltinAttributes.cpp
--- a/mlir/lib/IR/BuiltinAttributes.cpp
+++ b/mlir/lib/IR/BuiltinAttributes.cpp
@@ -761,6 +761,9 @@
 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> {};
@@ -876,6 +879,7 @@
 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>;
diff --git a/mlir/test/IR/attribute.mlir b/mlir/test/IR/attribute.mlir
--- a/mlir/test/IR/attribute.mlir
+++ b/mlir/test/IR/attribute.mlir
@@ -592,6 +592,8 @@
                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>,
@@ -605,7 +607,9 @@
 // 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
@@ -617,6 +621,8 @@
                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]
@@ -655,6 +661,7 @@
   "test.confined_dense_array_attr"() {
     i64attr = array<i64: 0, 2, 3>,
     i32attr = array<i32: 1>,
+    ui32attr = array<ui32: 10>,
     emptyattr = array<i16>
   } : () -> ()
   func.return
@@ -666,6 +673,7 @@
   // 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>
   } : () -> ()
@@ -678,6 +686,7 @@
   // 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>
   } : () -> ()
@@ -690,6 +699,7 @@
   "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>,
@@ -706,6 +716,7 @@
   "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>,
diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td
--- a/mlir/test/lib/Dialect/Test/TestOps.td
+++ b/mlir/test/lib/Dialect/Test/TestOps.td
@@ -300,6 +300,7 @@
     DenseI8ArrayAttr:$i8attr,
     DenseI16ArrayAttr:$i16attr,
     DenseI32ArrayAttr:$i32attr,
+    DenseUI32ArrayAttr:$ui32attr,
     DenseI64ArrayAttr:$i64attr,
     DenseF32ArrayAttr:$f32attr,
     DenseF64ArrayAttr:$f64attr,
@@ -307,7 +308,7 @@
   );
   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
   }];
 }
@@ -320,6 +321,8 @@
   let arguments = (ins
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayStrictlySorted<DenseI16ArrayAttr>]>:$emptyattr,
+      ConfinedAttr<DenseUI32ArrayAttr,
+                   [DenseArraySorted<DenseUI32ArrayAttr>]>:$ui32attr,
       ConfinedAttr<DenseI32ArrayAttr,
                    [DenseArraySorted<DenseI32ArrayAttr>]>:$i32attr,
       ConfinedAttr<DenseI64ArrayAttr,
@@ -334,6 +337,8 @@
                    [DenseArrayStrictlyPositive<DenseI8ArrayAttr>]>:$i8attr,
       ConfinedAttr<DenseI16ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI16ArrayAttr>]>:$i16attr,
+      ConfinedAttr<DenseUI32ArrayAttr,
+                   [DenseArrayStrictlyPositive<DenseUI32ArrayAttr>]>:$ui32attr,
       ConfinedAttr<DenseI32ArrayAttr,
                    [DenseArrayStrictlyPositive<DenseI32ArrayAttr>]>:$i32attr,
       ConfinedAttr<DenseI64ArrayAttr,
@@ -347,7 +352,7 @@
   );
 }
 
-// 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