diff --git a/mlir/include/mlir/IR/BuiltinAttributes.td b/mlir/include/mlir/IR/BuiltinAttributes.td
--- a/mlir/include/mlir/IR/BuiltinAttributes.td
+++ b/mlir/include/mlir/IR/BuiltinAttributes.td
@@ -155,8 +155,11 @@
   }];
 }
 
-def Builtin_DenseArray : Builtin_Attr<
-    "DenseArray", [ElementsAttrInterface, TypedAttrInterface]> {
+def Builtin_DenseArray : Builtin_Attr<"DenseArray", [
+    DeclareAttrInterfaceMethods<ElementsAttrInterface,
+                                ["getValuesImpl", "isSplat"]>,
+    TypedAttrInterface
+  ]> {
   let summary = "A dense array of integer or floating point elements.";
   let description = [{
     A dense array attribute is an attribute that represents a dense array of
@@ -206,24 +209,6 @@
     }]>,
   ];
 
-  let extraClassDeclaration = [{
-    /// Allow implicit conversion to ElementsAttr.
-    operator ElementsAttr() const {
-      return *this ? cast<ElementsAttr>() : nullptr;
-    }
-
-    /// ElementsAttr implementation.
-    using ContiguousIterableTypesT =
-        std::tuple<bool, int8_t, int16_t, int32_t, int64_t, float, double>;
-    const bool *value_begin_impl(OverloadToken<bool>) const;
-    const int8_t *value_begin_impl(OverloadToken<int8_t>) const;
-    const int16_t *value_begin_impl(OverloadToken<int16_t>) const;
-    const int32_t *value_begin_impl(OverloadToken<int32_t>) const;
-    const int64_t *value_begin_impl(OverloadToken<int64_t>) const;
-    const float *value_begin_impl(OverloadToken<float>) const;
-    const double *value_begin_impl(OverloadToken<double>) const;
-  }];
-
   let genVerifyDecl = 1;
 }
 
diff --git a/mlir/lib/AsmParser/AttributeParser.cpp b/mlir/lib/AsmParser/AttributeParser.cpp
--- a/mlir/lib/AsmParser/AttributeParser.cpp
+++ b/mlir/lib/AsmParser/AttributeParser.cpp
@@ -855,9 +855,11 @@
 } // namespace
 
 void DenseArrayElementParser::append(const APInt &data) {
-  llvm::append_range(
-      rawData, ArrayRef<char>(reinterpret_cast<const char *>(data.getRawData()),
-                              data.getBitWidth() / 8));
+  unsigned byteSize = data.getBitWidth() / 8;
+  size_t offset = rawData.size();
+  rawData.insert(rawData.end(), byteSize, 0);
+  llvm::StoreIntToMemory(
+      data, reinterpret_cast<uint8_t *>(rawData.data() + offset), byteSize);
   ++size;
 }
 
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
@@ -1892,11 +1892,11 @@
 
 /// Print the integer element of a DenseElementsAttr.
 static void printDenseIntElement(const APInt &value, raw_ostream &os,
-                                 bool isSigned) {
-  if (value.getBitWidth() == 1)
+                                 Type type) {
+  if (type.isInteger(1))
     os << (value.getBoolValue() ? "true" : "false");
   else
-    value.print(os, isSigned);
+    value.print(os, !type.isUnsignedInteger());
 }
 
 static void
@@ -1990,14 +1990,13 @@
     // printDenseElementsAttrImpl. This lambda was hitting a bug in gcc 9.1,9.2
     // and hence was replaced.
     if (complexElementType.isa<IntegerType>()) {
-      bool isSigned = !complexElementType.isUnsignedInteger();
       auto valueIt = attr.value_begin<std::complex<APInt>>();
       printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
         auto complexValue = *(valueIt + index);
         os << "(";
-        printDenseIntElement(complexValue.real(), os, isSigned);
+        printDenseIntElement(complexValue.real(), os, complexElementType);
         os << ",";
-        printDenseIntElement(complexValue.imag(), os, isSigned);
+        printDenseIntElement(complexValue.imag(), os, complexElementType);
         os << ")";
       });
     } else {
@@ -2012,10 +2011,9 @@
       });
     }
   } else if (elementType.isIntOrIndex()) {
-    bool isSigned = !elementType.isUnsignedInteger();
     auto valueIt = attr.value_begin<APInt>();
     printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
-      printDenseIntElement(*(valueIt + index), os, isSigned);
+      printDenseIntElement(*(valueIt + index), os, elementType);
     });
   } else {
     assert(elementType.isa<FloatType>() && "unexpected element type");
@@ -2036,19 +2034,17 @@
 void AsmPrinter::Impl::printDenseArrayAttr(DenseArrayAttr attr) {
   Type type = attr.getElementType();
   unsigned bitwidth = type.isInteger(1) ? 8 : type.getIntOrFloatBitWidth();
+  unsigned byteSize = bitwidth / 8;
   ArrayRef<char> data = attr.getRawData();
 
   auto printElementAt = [&](unsigned i) {
-    // FIXME: The data needs to be padded, requiring an extra copy.
-    SmallVector<char, 8> padded(data.slice(bitwidth / 8 * i, bitwidth / 8));
-    padded.append(
-        APInt::APINT_WORD_SIZE - padded.size() % APInt::APINT_WORD_SIZE, 0);
-    APInt value(type.getIntOrFloatBitWidth(),
-                {reinterpret_cast<const uint64_t *>(padded.data()),
-                 padded.size() / APInt::APINT_WORD_SIZE});
+    APInt value(bitwidth, 0);
+    llvm::LoadIntFromMemory(
+        value, reinterpret_cast<const uint8_t *>(data.begin() + byteSize * i),
+        byteSize);
     // Print the data as-is or as a float.
     if (type.isIntOrIndex()) {
-      printDenseIntElement(value, getStream(), !type.isUnsignedInteger());
+      printDenseIntElement(value, getStream(), type);
     } else {
       APFloat fltVal(type.cast<FloatType>().getFloatSemantics(), value);
       printFloatValue(fltVal, getStream());
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
@@ -709,28 +709,46 @@
   return success();
 }
 
-const bool *DenseArrayAttr::value_begin_impl(OverloadToken<bool>) const {
-  return cast<DenseBoolArrayAttr>().asArrayRef().begin();
-}
-const int8_t *DenseArrayAttr::value_begin_impl(OverloadToken<int8_t>) const {
-  return cast<DenseI8ArrayAttr>().asArrayRef().begin();
-}
-const int16_t *DenseArrayAttr::value_begin_impl(OverloadToken<int16_t>) const {
-  return cast<DenseI16ArrayAttr>().asArrayRef().begin();
-}
-const int32_t *DenseArrayAttr::value_begin_impl(OverloadToken<int32_t>) const {
-  return cast<DenseI32ArrayAttr>().asArrayRef().begin();
-}
-const int64_t *DenseArrayAttr::value_begin_impl(OverloadToken<int64_t>) const {
-  return cast<DenseI64ArrayAttr>().asArrayRef().begin();
-}
-const float *DenseArrayAttr::value_begin_impl(OverloadToken<float>) const {
-  return cast<DenseF32ArrayAttr>().asArrayRef().begin();
-}
-const double *DenseArrayAttr::value_begin_impl(OverloadToken<double>) const {
-  return cast<DenseF64ArrayAttr>().asArrayRef().begin();
+//===----------------------------------------------------------------------===//
+// ElementsAttr Implementation
+
+/// A dense array is never a splat.
+bool DenseArrayAttr::isSplat() const { return false; }
+
+/// Try to dispatch to the given dense array subclass to contiguously iterate
+/// its elements.
+template <typename DenseArrayT>
+static FailureOr<detail::ElementsAttrIndexer>
+tryContainerBegin(DenseArrayAttr attr) {
+  if (auto container = attr.dyn_cast<DenseArrayT>())
+    return detail::ElementsAttrIndexer::contiguous(
+        /*isSplat=*/false, container.asArrayRef().begin());
+  return failure();
+}
+
+/// Re-implement `getValuesImpl` to dynamically dispatch to subclasses.
+FailureOr<detail::ElementsAttrIndexer>
+DenseArrayAttr::getValuesImpl(TypeID elementID) const {
+  if (elementID == TypeID::get<bool>())
+    return tryContainerBegin<DenseBoolArrayAttr>(*this);
+  if (elementID == TypeID::get<int8_t>())
+    return tryContainerBegin<DenseI8ArrayAttr>(*this);
+  if (elementID == TypeID::get<int16_t>())
+    return tryContainerBegin<DenseI16ArrayAttr>(*this);
+  if (elementID == TypeID::get<int32_t>())
+    return tryContainerBegin<DenseI32ArrayAttr>(*this);
+  if (elementID == TypeID::get<int64_t>())
+    return tryContainerBegin<DenseI64ArrayAttr>(*this);
+  if (elementID == TypeID::get<float>())
+    return tryContainerBegin<DenseF32ArrayAttr>(*this);
+  if (elementID == TypeID::get<double>())
+    return tryContainerBegin<DenseF64ArrayAttr>(*this);
+  return failure();
 }
 
+//===----------------------------------------------------------------------===//
+// DenseArrayAttrUtil
+
 namespace {
 /// Instantiations of this class provide utilities for interacting with native
 /// data types in the context of DenseArrayAttr.
@@ -814,6 +832,9 @@
 };
 } // namespace
 
+//===----------------------------------------------------------------------===//
+// DenseArrayAttrImpl
+
 template <typename T>
 void DenseArrayAttrImpl<T>::print(AsmPrinter &printer) const {
   print(printer.getStream());