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
@@ -26,6 +26,8 @@
 class Location;
 class Operation;
 class ShapedType;
+class AsmParser;
+class AsmPrinter;
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
@@ -64,9 +66,60 @@
 template <typename T> struct is_complex_t : public std::false_type {};
 template <typename T>
 struct is_complex_t<std::complex<T>> : public std::true_type {};
+
+class DenseArrayAttributeStorage;
+enum class DenseArrayAttributeElementType { None, I8, I16, I32, I64, F32, F64 };
 } // namespace detail
 
-/// An attribute that represents a reference to a dense vector or tensor object.
+class DenseArrayAttrBase
+    : public Attribute::AttrBase<DenseArrayAttrBase, Attribute,
+                                 detail::DenseArrayAttributeStorage,
+                                 ElementsAttr::Trait> {
+public:
+  using Base::Base;
+
+  /// Allow implicit conversion to ElementsAttr.
+  operator ElementsAttr() const {
+    return *this ? cast<ElementsAttr>() : nullptr;
+  }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast.
+  detail::DenseArrayAttributeElementType getElementType() const;
+  void print(AsmPrinter &printer) const;
+  void print(raw_ostream &os) const;
+};
+
+template <typename T>
+class DenseArrayAttr : public DenseArrayAttrBase {
+public:
+  using DenseArrayAttrBase::DenseArrayAttrBase;
+  operator ArrayRef<T>() const;
+  static DenseArrayAttr get(MLIRContext *context, ArrayRef<T> content);
+
+  static Attribute parse(AsmParser &parser, Type odsType);
+  void print(AsmPrinter &printer) const;
+  void print(raw_ostream &os) const;
+
+  static bool classof(Attribute attr);
+};
+template <>
+void DenseArrayAttr<int8_t>::print(raw_ostream &os) const;
+
+extern template class DenseArrayAttr<int8_t>;
+extern template class DenseArrayAttr<int16_t>;
+extern template class DenseArrayAttr<int32_t>;
+extern template class DenseArrayAttr<int64_t>;
+extern template class DenseArrayAttr<float>;
+extern template class DenseArrayAttr<double>;
+using DenseI8ArrayAttr = DenseArrayAttr<int8_t>;
+using DenseI16ArrayAttr = DenseArrayAttr<int16_t>;
+using DenseI32ArrayAttr = DenseArrayAttr<int32_t>;
+using DenseI64ArrayAttr = DenseArrayAttr<int64_t>;
+using DenseF32ArrayAttr = DenseArrayAttr<float>;
+using DenseF64ArrayAttr = DenseArrayAttr<double>;
+
+/// An attribute that represents a reference to a dense vector or tensor
+/// object.
 ///
 class DenseElementsAttr : public Attribute {
 public:
diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td
--- a/mlir/include/mlir/IR/OpBase.td
+++ b/mlir/include/mlir/IR/OpBase.td
@@ -1517,6 +1517,60 @@
   let convertFromStorage = "$_self";
 }
 
+def DenseI8ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseI8ArrayAttr>()">,
+                     "i8 dense array attribute"> {
+  let storageType = [{ ::mlir::DenseI8ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<int8_t> }];
+
+  let convertFromStorage = "$_self";
+}
+
+def DenseI16ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseI16ArrayAttr>()">,
+                     "i16 dense array attribute"> {
+  let storageType = [{ ::mlir::DenseI16ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<int16_t> }];
+
+  let convertFromStorage = "$_self";
+}
+
+def DenseI32ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseI32ArrayAttr>()">,
+                     "i32 dense array attribute"> {
+  let storageType = [{ ::mlir::DenseI32ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<int32_t> }];
+
+  let convertFromStorage = "$_self";
+}
+
+def DenseI64ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseI64ArrayAttr>()">,
+                     "i64 dense array attribute"> {
+  let storageType = [{ ::mlir::DenseI64ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<int64_t> }];
+
+  let convertFromStorage = "$_self";
+}
+
+def DenseF32ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseF32ArrayAttr>()">,
+                     "float dense array attribute"> {
+  let storageType = [{ ::mlir::DenseF32ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<float> }];
+
+  let convertFromStorage = "$_self";
+}
+
+def DenseF64ArrayAttr :
+    ElementsAttrBase<CPred<"$_self.isa<::mlir::DenseF64ArrayAttr>()">,
+                     "double dense array attribute"> {
+  let storageType = [{ ::mlir::DenseF64ArrayAttr }];
+  let returnType = [{ ::llvm::ArrayRef<double> }];
+
+  let convertFromStorage = "$_self";
+}
+
 def IndexElementsAttr
     : IntElementsAttrBase<CPred<[{$_self.cast<::mlir::DenseIntElementsAttr>()
                                       .getType()
diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp
--- a/mlir/lib/IR/AsmPrinter.cpp
+++ b/mlir/lib/IR/AsmPrinter.cpp
@@ -1822,9 +1822,36 @@
       }
       os << '>';
     }
-
+  } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayAttrBase>()) {
+    os << "arrayref ";
+    switch (denseArrayAttr.getElementType()) {
+    case detail::DenseArrayAttributeElementType::None:
+      os << "<none> ";
+      break;
+    case detail::DenseArrayAttributeElementType::I8:
+      os << "i8 ";
+      break;
+    case detail::DenseArrayAttributeElementType::I16:
+      os << "i16 ";
+      break;
+    case detail::DenseArrayAttributeElementType::I32:
+      os << "i32 ";
+      break;
+    case detail::DenseArrayAttributeElementType::I64:
+      os << "i64 ";
+      break;
+    case detail::DenseArrayAttributeElementType::F32:
+      os << "f32 ";
+      break;
+    case detail::DenseArrayAttributeElementType::F64:
+      os << "f64 ";
+      break;
+    }
+    denseArrayAttr.print(os);
   } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
     printLocation(locAttr);
+  } else {
+    llvm::report_fatal_error("Unknown builtin attribute");
   }
   // Don't print the type if we must elide it, or if it is a None type.
   if (typeElision != AttrTypeElision::Must && !attrType.isa<NoneType>()) {
diff --git a/mlir/lib/IR/AttributeDetail.h b/mlir/lib/IR/AttributeDetail.h
--- a/mlir/lib/IR/AttributeDetail.h
+++ b/mlir/lib/IR/AttributeDetail.h
@@ -40,6 +40,36 @@
   return eltType.getIntOrFloatBitWidth();
 }
 
+/// TODO
+struct DenseArrayAttributeStorage : public AttributeStorage {
+  using KeyTy =
+      std::tuple<DenseArrayAttributeElementType, ::llvm::ArrayRef<char>>;
+  DenseArrayAttributeStorage(DenseArrayAttributeElementType eltType,
+                             ArrayRef<char> elements)
+      : eltType(eltType), elements(elements) {}
+
+  bool operator==(const KeyTy &tblgenKey) const {
+    return (eltType == std::get<0>(tblgenKey)) &&
+           (elements == std::get<1>(tblgenKey));
+  }
+
+  static ::llvm::hash_code hashKey(const KeyTy &tblgenKey) {
+    return ::llvm::hash_combine(std::get<0>(tblgenKey), std::get<1>(tblgenKey));
+  }
+
+  static DenseArrayAttributeStorage *
+  construct(::mlir::AttributeStorageAllocator &allocator,
+            const KeyTy &tblgenKey) {
+    auto eltType = std::get<0>(tblgenKey);
+    auto elements = std::get<1>(tblgenKey);
+    elements = allocator.copyInto(elements);
+    return new (allocator.allocate<DenseArrayAttributeStorage>())
+        DenseArrayAttributeStorage(eltType, elements);
+  }
+  DenseArrayAttributeElementType eltType;
+  ::llvm::ArrayRef<char> elements;
+};
+
 /// An attribute representing a reference to a dense vector or tensor object.
 struct DenseElementsAttributeStorage : public AttributeStorage {
 public:
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
@@ -12,6 +12,7 @@
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/IntegerSet.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/IR/Types.h"
@@ -35,11 +36,11 @@
 //===----------------------------------------------------------------------===//
 
 void BuiltinDialect::registerAttributes() {
-  addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
-                DenseStringElementsAttr, DictionaryAttr, FloatAttr,
-                SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
-                OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
-                UnitAttr>();
+  addAttributes<AffineMapAttr, ArrayAttr, DenseArrayAttrBase,
+                DenseIntOrFPElementsAttr, DenseStringElementsAttr,
+                DictionaryAttr, FloatAttr, SymbolRefAttr, IntegerAttr,
+                IntegerSetAttr, OpaqueAttr, OpaqueElementsAttr,
+                SparseElementsAttr, StringAttr, TypeAttr, UnitAttr>();
 }
 
 //===----------------------------------------------------------------------===//
@@ -664,6 +665,149 @@
           readBits(getData(), offset + storageWidth, bitWidth)};
 }
 
+//===----------------------------------------------------------------------===//
+// DenseArrayAttr
+//===----------------------------------------------------------------------===//
+
+detail::DenseArrayAttributeElementType
+DenseArrayAttrBase::getElementType() const {
+  return getImpl()->eltType;
+}
+
+void DenseArrayAttrBase::print(AsmPrinter &printer) const {
+  print(printer.getStream());
+}
+
+void DenseArrayAttrBase::print(raw_ostream &os) const {
+  switch (getElementType()) {
+  case detail::DenseArrayAttributeElementType::I8:
+    this->cast<DenseI8ArrayAttr>().print(os);
+    return;
+  case detail::DenseArrayAttributeElementType::I16:
+    this->cast<DenseI16ArrayAttr>().print(os);
+    return;
+  case detail::DenseArrayAttributeElementType::I32:
+    this->cast<DenseI32ArrayAttr>().print(os);
+    return;
+  case detail::DenseArrayAttributeElementType::I64:
+    this->cast<DenseI64ArrayAttr>().print(os);
+    return;
+  case detail::DenseArrayAttributeElementType::F32:
+    this->cast<DenseF32ArrayAttr>().print(os);
+    return;
+  case detail::DenseArrayAttributeElementType::F64:
+    this->cast<DenseF64ArrayAttr>().print(os);
+    return;
+  default:
+    os << "<unknown DenseArrayAttrBase>";
+    return;
+  }
+}
+
+template <typename T>
+void DenseArrayAttr<T>::print(AsmPrinter &printer) const {
+  print(printer.getStream());
+}
+
+template <typename T>
+void DenseArrayAttr<T>::print(raw_ostream &os) const {
+  ArrayRef<T> values{*this};
+  os << "[";
+  llvm::interleaveComma(values, os);
+  os << "]";
+}
+
+template <>
+void DenseArrayAttr<int8_t>::print(raw_ostream &os) const {
+  ArrayRef<int8_t> values{*this};
+  os << "[";
+  llvm::interleaveComma(values, os, [&](int64_t v) { os << v; });
+  os << "]";
+}
+
+template <typename T>
+Attribute DenseArrayAttr<T>::parse(AsmParser &parser, Type odsType) {
+  if (parser.parseLSquare())
+    return {};
+  SmallVector<T> data;
+  do {
+    T value;
+    if (parser.parseInteger(value))
+      return {};
+    data.push_back(value);
+    if (parser.parseOptionalComma())
+      break;
+  } while (1);
+
+  if (parser.parseRSquare())
+    return {};
+  return get(parser.getContext(), data);
+}
+
+template <typename T>
+DenseArrayAttr<T>::operator ArrayRef<T>() const {
+  ArrayRef<char> raw = getImpl()->elements;
+  assert((raw.size() % sizeof(T)) == 0);
+  return ArrayRef<T>(reinterpret_cast<const T *>(raw.data()),
+                     raw.size() / sizeof(T));
+}
+
+namespace {
+template <typename T>
+constexpr detail::DenseArrayAttributeElementType denseArrayAttrEltTypeMap =
+    detail::DenseArrayAttributeElementType::None;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<int8_t> =
+        detail::DenseArrayAttributeElementType::I8;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<int16_t> =
+        detail::DenseArrayAttributeElementType::I16;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<int32_t> =
+        detail::DenseArrayAttributeElementType::I32;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<int64_t> =
+        detail::DenseArrayAttributeElementType::I64;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<float> =
+        detail::DenseArrayAttributeElementType::F32;
+template <>
+constexpr detail::DenseArrayAttributeElementType
+    denseArrayAttrEltTypeMap<double> =
+        detail::DenseArrayAttributeElementType::F64;
+} // namespace
+
+template <typename T>
+DenseArrayAttr<T> DenseArrayAttr<T>::get(MLIRContext *context,
+                                         ArrayRef<T> content) {
+  return Base::get(
+             context, denseArrayAttrEltTypeMap<T>,
+             ArrayRef<char>(reinterpret_cast<const char *>(content.data()),
+                            content.size() * sizeof(T)))
+      .template cast<DenseArrayAttr<T>>();
+}
+
+template <typename T>
+bool DenseArrayAttr<T>::classof(Attribute attr) {
+  return attr.isa<DenseArrayAttrBase>() &&
+         attr.cast<DenseArrayAttrBase>().getElementType() ==
+             denseArrayAttrEltTypeMap<T>;
+}
+
+namespace mlir {
+template class DenseArrayAttr<int8_t>;
+template class DenseArrayAttr<int16_t>;
+template class DenseArrayAttr<int32_t>;
+template class DenseArrayAttr<int64_t>;
+template class DenseArrayAttr<float>;
+template class DenseArrayAttr<double>;
+} // namespace mlir
+
 //===----------------------------------------------------------------------===//
 // DenseElementsAttr
 //===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Parser/AttributeParser.cpp b/mlir/lib/Parser/AttributeParser.cpp
--- a/mlir/lib/Parser/AttributeParser.cpp
+++ b/mlir/lib/Parser/AttributeParser.cpp
@@ -14,6 +14,7 @@
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Parser/AsmParserState.h"
 #include "llvm/ADT/StringExtras.h"
@@ -35,6 +36,7 @@
 ///                    | symbol-ref-id (`::` symbol-ref-id)*
 ///                    | `dense` `<` tensor-literal `>` `:`
 ///                      (tensor-type | vector-type)
+///                    | arrayref (integer-type | float-type) <tensor-literal>
 ///                    | `sparse` `<` attribute-value `,` attribute-value `>`
 ///                      `:` (tensor-type | vector-type)
 ///                    | `opaque` `<` dialect-namespace  `,` hex-string-literal
@@ -90,6 +92,10 @@
   case Token::kw_dense:
     return parseDenseElementsAttr(type);
 
+  // Parse a DenseArrayAttr
+  case Token::kw_arrayref:
+    return parseDenseArrayAttr();
+
   // Parse a dictionary attribute.
   case Token::l_brace: {
     NamedAttrList elements;
@@ -806,6 +812,126 @@
 // ElementsAttr Parser
 //===----------------------------------------------------------------------===//
 
+/// Parse a dense elements attribute.
+Attribute Parser::parseDenseArrayAttr() {
+  consumeToken(Token::kw_arrayref);
+
+  auto typeLoc = getToken().getLoc();
+  auto type = parseType();
+  auto intType = type.dyn_cast<IntegerType>();
+  auto floatType = type.dyn_cast<FloatType>();
+  if (!intType && !floatType) {
+    emitError(typeLoc, "expected integer or float type, got: ") << type;
+    return {};
+  }
+  int bitWidth = type.getIntOrFloatBitWidth();
+  switch (bitWidth) {
+  case 8:
+    LLVM_FALLTHROUGH;
+  case 16:
+    LLVM_FALLTHROUGH;
+  case 32:
+    LLVM_FALLTHROUGH;
+  case 64:
+    break;
+  default:
+    if (intType)
+      emitError(typeLoc, "expected i8, i16, i32, or i64 but got: ") << type;
+    else
+      emitError(typeLoc, "expected f32 or f64 but got: ") << type;
+    return {};
+  }
+
+  if (parseToken(Token::l_square, "expected '[' after 'arrayref'"))
+    return nullptr;
+
+  auto parseIntegerList = [&](auto &data) -> LogicalResult {
+    do {
+      bool neg = false;
+      if (getToken().is(Token::minus)) {
+        neg = true;
+        consumeToken();
+      }
+      if (!getToken().is(Token::integer)) {
+        emitError("expected integer literal");
+        return failure();
+      }
+      auto optionalValue = getToken().getUInt64IntegerValue();
+      if (!optionalValue.hasValue()) {
+        emitError("invalid integer literal");
+        return failure();
+      }
+      using value_type =
+          typename std::remove_reference<decltype(data)>::type::value_type;
+      int64_t value = optionalValue.getValue();
+      value = neg ? -value : value;
+      value_type min = std::numeric_limits<value_type>::min();
+      value_type max = std::numeric_limits<value_type>::max();
+      if (value < min || value > max) {
+        emitError("overflow expected integer [")
+            << min << ", " << max << "]: " << value;
+        return failure();
+      }
+      data.push_back(value);
+      consumeToken();
+      if (!getToken().is(Token::comma))
+        break;
+      consumeToken();
+    } while (1);
+    return success();
+  };
+  Attribute result;
+  if (intType) {
+    switch (bitWidth) {
+    case 8: {
+      SmallVector<int8_t> data;
+      if (failed(parseIntegerList(data)))
+        return {};
+      result = DenseI8ArrayAttr::get(getContext(), data);
+      break;
+    }
+    case 16: {
+      SmallVector<int16_t> data;
+      if (failed(parseIntegerList(data)))
+        return {};
+      result = DenseI16ArrayAttr::get(getContext(), data);
+      break;
+    }
+    case 32: {
+      SmallVector<int32_t> data;
+      if (failed(parseIntegerList(data)))
+        return {};
+      result = DenseI32ArrayAttr::get(getContext(), data);
+      break;
+    }
+    case 64: {
+      SmallVector<int64_t> data;
+      if (failed(parseIntegerList(data)))
+        return {};
+      result = DenseI64ArrayAttr::get(getContext(), data);
+      break;
+    }
+    }
+  } else {
+    llvm::report_fatal_error("dense array float not implemented");
+  }
+
+  if (parseToken(Token::r_square, "expected ']' after 'arrayref'"))
+    return {};
+  return result;
+}
+
+template <>
+struct FieldParser<DenseArrayAttrBase> {
+  static FailureOr<DenseArrayAttrBase> parse(AsmParser &parser) {
+    auto value = FieldParser<int>::parse(parser);
+    if (failed(value))
+      return failure();
+    return {};
+    // DenseArrayAttrBase::get(parser.getContext(), ArrayRef<int8_t>{});
+  }
+};
+
 /// Parse a dense elements attribute.
 Attribute Parser::parseDenseElementsAttr(Type attrType) {
   auto attribLoc = getToken().getLoc();
diff --git a/mlir/lib/Parser/Parser.h b/mlir/lib/Parser/Parser.h
--- a/mlir/lib/Parser/Parser.h
+++ b/mlir/lib/Parser/Parser.h
@@ -265,6 +265,9 @@
   Attribute parseDenseElementsAttr(Type attrType);
   ShapedType parseElementsLiteralType(Type type);
 
+  /// Parse a DenseArrayAttr.
+  Attribute parseDenseArrayAttr();
+
   /// Parse a sparse elements attribute.
   Attribute parseSparseElementsAttr(Type attrType);
 
diff --git a/mlir/lib/Parser/TokenKinds.def b/mlir/lib/Parser/TokenKinds.def
--- a/mlir/lib/Parser/TokenKinds.def
+++ b/mlir/lib/Parser/TokenKinds.def
@@ -78,6 +78,7 @@
 TOK_KEYWORD(affine_map)
 TOK_KEYWORD(affine_set)
 TOK_KEYWORD(attributes)
+TOK_KEYWORD(arrayref)
 TOK_KEYWORD(bf16)
 TOK_KEYWORD(ceildiv)
 TOK_KEYWORD(complex)
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
@@ -500,6 +500,30 @@
   return
 }
 
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Test DenseArrayAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK-LABEL: func @dense_array_attr
+// CHECK: i16attr = arrayref i16 [1, -2, 3]
+func @dense_array_attr() attributes{ i16attr = arrayref i16 [1, -2, 3] } {
+// CHECK:  test.dense_array_attr
+// CHECK-SAME: i8attr = [1, -2, 3]
+// CHECK-SAME: i16attr = [3, 5, -4, 10]
+// CHECK-SAME: i32attr = [1024, 453, -6435]
+// CHECK-SAME: i64attr = [-142]
+  test.dense_array_attr
+    i8attr = [1, -2, 3]
+    i16attr = [3, 5, -4, 10]
+    i32attr = [1024, 453, -6435]
+    i64attr = [-142]
+
+  return
+}
+
 // -----
 
 //===----------------------------------------------------------------------===//
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
@@ -289,6 +289,21 @@
   );
 }
 
+def DenseArrayAttrOp : TEST_Op<"dense_array_attr"> {
+  let arguments = (ins
+    DenseI8ArrayAttr:$i8attr,
+    DenseI16ArrayAttr:$i16attr,
+    DenseI32ArrayAttr:$i32attr,
+    DenseI64ArrayAttr:$i64attr
+//    DenseF32ArrayAttr:$f32attr,
+//    DenseF64ArrayAttr:$f64attr
+  );
+  let assemblyFormat = [{
+   `i8attr` `=` $i8attr `i16attr` `=` $i16attr `i32attr` `=` $i32attr `i64attr` `=` $i64attr attr-dict
+  }];
+}
+
+
 //===----------------------------------------------------------------------===//
 // Test Enum Attributes
 //===----------------------------------------------------------------------===//