DenseStringElementsAttr added to default attribute types

[rsuderman]

Summary

Implemented a DenseStringsElements attr for handling arrays / tensors of strings. This includes the
necessary logic for parsing and printing the attribute from MLIR's text format.

To store the attribute we perform a single allocation that includes all wrapped string data tightly packed.
This means no padding characters and no null terminators (as they could be present in the string). This
buffer includes a first chunk of data that represents an array of StringRefs, that contain address pointers
into the string data, with the length of each string wrapped. At this point there is no Sparse representation
however strings are not typically represented sparsely.

[rriddle]

Thanks for adding this! I think this can prove to be extremely useful for dense string storage. Can you beef up the description a bit to include a bit more of the internal design? i.e. what strategy you are using to make it "dense".

mlir/lib/IR/AttributeDetail.h

629

nit: This block is a bit long, can you switch to early exit here?

643

Please use camelCase for variable names.

mlir/lib/Parser/Parser.cpp

2303

nit: Drop trivial braces.

mlir/test/lib/Dialect/Test/TestDialect.cpp

169 ↗

(On Diff #259132)

Can you replace all of the custom type stuff here with just an opaque type? Opaque types don't need to be registered, and seem like they could serve the same purpose without any additional code. I think you could just add allowUnknownTypes to the constructor of TestDialect, remove all of the other C++ for Test types, and the tests would still work.

[rriddle]

This looks pretty good, I left some initial comments and will try to give a more detailed review tomorrow.

[rsuderman]

Updated for rriddle@ comments

[rsuderman]

Updating with full diff

[rsuderman]

Squashed commits.

[rsuderman]

Missed one comment

[rsuderman]

Addressed code comments and updated CL description.

[rriddle]

It seems like right now, the storage strategy is:

<StringRef * N><StringData>

Have you considered other strategies?

1. You could unique the strings on construction and build a string table instead of storing each string individually.

2. Instead of storing StringRef for each element, you could store an index into the string data. If you don't unique the strings, the size of the string is just the nextOffset - current. If you do unique, you can store the length as a string table entry.

Can you share some examples of the types of data that you can expect to be stored here? and any characteristics we might want to optimize around.

mlir/include/mlir/IR/Attributes.h

145–146

Can we rename this to DenseIntOrFPElements?

950

Can you add the proper equivalents getValues<StringRef> accessors? It also allows for getValue/getSplatValue/etc. to "just work".

1006

Can you add class comments to these?

1019

I would have expected this to return a range of ElementIterator<StringRef>. If the data is a splat, we will need to repeat the value N times.

Also, can we sink this into DenseElementsAttr?

mlir/lib/IR/AsmPrinter.cpp

1508

Can you add this to DenseStringElementsAttr as well? We want to avoid pretty printing huge tensors.

1557

nit: Drop the username from the TODO.

mlir/lib/IR/AttributeDetail.h

596

nit: remove trivial braces.

638

Did you mean sizeof(StringRef) * numEntries?

639

nit: Drop trivial braces.

[rsuderman]

rriddle@ comments round 2

[rsuderman]

Tweaked iterator behavior.

[rsuderman]

Updated for the most part. I am not sure we can handle a dense serialization format like floats / strings due to the variable length of our data.

mlir/include/mlir/IR/Attributes.h

950

Updated to include both getValues and renamed getStringValues to getStringRefs.

mlir/lib/IR/AsmPrinter.cpp

1508

I am not certain the hex printer is going to be usable for printing multiple string attributes. Any binary representation of strings depends on encoding the number of elements, followed by the full binary data for each part. If you have a recommended serialization format that we can use for multiple strings, I am happy to look into it, however the current hex format won't be able to express hex strings.

[rsuderman]

Full diff

[rsuderman]

Deleted unnecessary newline

[rriddle]

Can you add support for SparseElementsAttr in a followup? It should be relatively straightforward as it uses DenseElementsAttr as the values internally.

mlir/include/mlir/IR/Attributes.h

890

nit: drop the llvm:: from the iterator_range

959

nit: getRawStringData?

1006

Please use /// for these comments.

mlir/lib/IR/AttributeDetail.h

644

nit: Please make the comment a complete sentence.

mlir/lib/Parser/Parser.cpp

2244

Please use the form /*...=*/

2302

This seems unrelated now?

[rsuderman]

Final comments a sync to head.

[rsuderman]

mlir/include/mlir/IR/Attributes.h

890

Dropping the llvm:: results in build errors.

[rsuderman]

Final comment.

[rriddle]

mlir/include/mlir/IR/Attributes.h

890

The llvm:: seems to still be here?

mlir/include/mlir/IR/Attributes.h

 struct IntegerSetAttributeStorage;
 struct FloatAttributeStorage;
 struct OpaqueAttributeStorage;
 struct StringAttributeStorage;
 struct SymbolRefAttributeStorage;
 struct TypeAttributeStorage;
 
 /// Elements Attributes.
-struct DenseElementsAttributeStorage;
+struct DenseIntOrFPElementsAttributeStorage;
+struct DenseStringElementsAttributeStorage;
 struct OpaqueElementsAttributeStorage;
 struct SparseElementsAttributeStorage;
 } // namespace detail
 
 /// Attributes are known-constant values of operations and functions.
 ///
 /// Instances of the Attribute class are references to immutable, uniqued,
 /// and immortal values owned by MLIRContext. As such, an Attribute is a thin
enum Kind {
   IntegerSet,
   Opaque,
   String,
   SymbolRef,
   Type,
   Unit,
 
   /// Elements Attributes.
-  DenseElements,
+  DenseIntOrFPElements,
+  DenseStringElements,
   OpaqueElements,
   SparseElements,
-  FIRST_ELEMENTS_ATTR = DenseElements,
+  FIRST_ELEMENTS_ATTR = DenseIntOrFPElements,
   LAST_ELEMENTS_ATTR = SparseElements,
 
   /// Locations.
   CallSiteLocation,
   FileLineColLocation,
   FusedLocation,
   NameLocation,
   OpaqueLocation,
protected:
 
   /// Return the data base pointer.
   const char *getData() const { return this->base.getPointer(); }
 };
 } // namespace detail
 
 /// An attribute that represents a reference to a dense vector or tensor object.
 ///
-class DenseElementsAttr
-    : public Attribute::AttrBase<DenseElementsAttr, ElementsAttr,
-                                 detail::DenseElementsAttributeStorage> {
+class DenseElementsAttr : public ElementsAttr {
 public:
-  using Base::Base;
+  using ElementsAttr::ElementsAttr;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr) {
-    return attr.getKind() == StandardAttributes::DenseElements;
+    return attr.getKind() == StandardAttributes::DenseIntOrFPElements ||
+           attr.getKind() == StandardAttributes::DenseStringElements;
   }
 
   /// Constructs a dense elements attribute from an array of element values.
   /// Each element attribute value is expected to be an element of 'type'.
   /// 'type' must be a vector or tensor with static shape.
   static DenseElementsAttr get(ShapedType type, ArrayRef<Attribute> values);
 
   /// Constructs a dense integer elements attribute from an array of integer
template <typename T, typename = typename std::enable_if<
                             llvm::is_one_of<T, float, double>::value>::type>
   static DenseElementsAttr get(const ShapedType &type, T value) {
     return get(type, llvm::makeArrayRef(value));
   }
 
   /// Overload of the above 'get' method that is specialized for boolean values.
   static DenseElementsAttr get(ShapedType type, ArrayRef<bool> values);
 
+  /// Overload of the above 'get' method that is specialized for StringRef
+  /// values.
+  static DenseElementsAttr get(ShapedType type, ArrayRef<StringRef> values);
+
   /// Constructs a dense integer elements attribute from an array of APInt
   /// values. Each APInt value is expected to have the same bitwidth as the
   /// element type of 'type'. 'type' must be a vector or tensor with static
   /// shape.
   static DenseElementsAttr get(ShapedType type, ArrayRef<APInt> values);
 
   /// Constructs a dense float elements attribute from an array of APFloat
   /// values. Each APFloat value is expected to have the same bitwidth as the
llvm::iterator_range<ElementIterator<T>> getValues() const {
     assert(isValidIntOrFloat(sizeof(T), std::numeric_limits<T>::is_integer,
                              std::numeric_limits<T>::is_signed));
     auto rawData = getRawData().data();
     bool splat = isSplat();
     return {ElementIterator<T>(rawData, splat, 0),
             ElementIterator<T>(rawData, splat, getNumElements())};
   }
 
+  llvm::iterator_range<ElementIterator<StringRef>> getValues() const {
+    auto stringRefs = getRawStringData();
+    const char *ptr = reinterpret_cast<const char *>(stringRefs.data());
+    bool splat = isSplat();
+    return {ElementIterator<StringRef>(ptr, splat, 0),
+            ElementIterator<StringRef>(ptr, splat, getNumElements())};
+  }
+
   /// Return the held element values as a range of Attributes.
   llvm::iterator_range<AttributeElementIterator> getAttributeValues() const;
   template <typename T, typename = typename std::enable_if<
                             std::is_same<T, Attribute>::value>::type>
   llvm::iterator_range<AttributeElementIterator> getValues() const {
     return getAttributeValues();
   }
   AttributeElementIterator attr_value_begin() const;
public:
   /// Return the held element values as a range of APFloat. The element type of
   /// this attribute must be of float type.
   llvm::iterator_range<FloatElementIterator> getFloatValues() const;
   template <typename T, typename = typename std::enable_if<
                             std::is_same<T, APFloat>::value>::type>
   llvm::iterator_range<FloatElementIterator> getValues() const {
     return getFloatValues();
   }
   FloatElementIterator float_value_begin() const;
   FloatElementIterator float_value_end() const;
 
   /// Return the raw storage data held by this attribute. Users should generally
   /// not use this directly, as the internal storage format is not always in the
   /// form the user might expect.
   ArrayRef<char> getRawData() const;
 
+  /// Return the raw StringRef data held by this attribute.
+  ArrayRef<StringRef> getRawStringData() const;
+
   //===--------------------------------------------------------------------===//
   // Mutation Utilities
   //===--------------------------------------------------------------------===//
 
   /// Return a new DenseElementsAttr that has the same data as the current
   /// attribute, but has been reshaped to 'newType'. The new type must have the
   /// same total number of elements as well as element type.
   DenseElementsAttr reshape(ShapedType newType);
protected:
   /// Get iterators to the raw APInt values for each element in this attribute.
   IntElementIterator raw_int_begin() const {
     return IntElementIterator(*this, 0);
   }
   IntElementIterator raw_int_end() const {
     return IntElementIterator(*this, getNumElements());
   }
 
+  /// Overload of the raw 'get' method that asserts that the given type is of
+  /// integer or floating-point type. This method is used to verify type
+  /// invariants that the templatized 'get' method cannot.
+  static DenseElementsAttr getRawIntOrFloat(ShapedType type,
+                                            ArrayRef<char> data,
+                                            int64_t dataEltSize, bool isInt,
+                                            bool isSigned);
+
+  /// Check the information for a C++ data type, check if this type is valid for
+  /// the current attribute. This method is used to verify specific type
+  /// invariants that the templatized 'getValues' method cannot.
+  bool isValidIntOrFloat(int64_t dataEltSize, bool isInt, bool isSigned) const;
+};
+
+/// An attribute class for representing dense arrays of strings. The structure
+/// storing and querying a list of densely packed strings.
+class DenseStringElementsAttr
+    : public Attribute::AttrBase<DenseStringElementsAttr, DenseElementsAttr,
+                                 detail::DenseStringElementsAttributeStorage> {
+
+public:
+  using Base::Base;
+
+  /// Method for support type inquiry through isa, cast and dyn_cast.
+  static bool kindof(unsigned kind) {
+    return kind == StandardAttributes::DenseStringElements;
+  }
+
+  /// Overload of the raw 'get' method that asserts that the given type is of
+  /// integer or floating-point type. This method is used to verify type
+  /// invariants that the templatized 'get' method cannot.
+  static DenseStringElementsAttr get(ShapedType type, ArrayRef<StringRef> data);
+
+protected:
+  friend DenseElementsAttr;
+};
+
+/// An attribute class for specializing behavior of Int and Floating-point
+/// densely packed string arrays.
+class DenseIntOrFPElementsAttr
+    : public Attribute::AttrBase<DenseIntOrFPElementsAttr, DenseElementsAttr,
+                                 detail::DenseIntOrFPElementsAttributeStorage> {
+
+public:
+  using Base::Base;
+
+  /// Method for support type inquiry through isa, cast and dyn_cast.
+  static bool kindof(unsigned kind) {
+    return kind == StandardAttributes::DenseIntOrFPElements;
+  }
+
+protected:
+  friend DenseElementsAttr;
+
   /// Constructs a dense elements attribute from an array of raw APInt values.
   /// Each APInt value is expected to have the same bitwidth as the element type
   /// of 'type'. 'type' must be a vector or tensor with static shape.
   static DenseElementsAttr getRaw(ShapedType type, ArrayRef<APInt> values);
 
   /// Get or create a new dense elements attribute instance with the given raw
   /// data buffer. 'type' must be a vector or tensor with static shape.
   static DenseElementsAttr getRaw(ShapedType type, ArrayRef<char> data,
                                   bool isSplat);
 
   /// Overload of the raw 'get' method that asserts that the given type is of
   /// integer or floating-point type. This method is used to verify type
   /// invariants that the templatized 'get' method cannot.
   static DenseElementsAttr getRawIntOrFloat(ShapedType type,
                                             ArrayRef<char> data,
                                             int64_t dataEltSize, bool isInt,
                                             bool isSigned);
-
-  /// Check the information for a C++ data type, check if this type is valid for
-  /// the current attribute. This method is used to verify specific type
-  /// invariants that the templatized 'getValues' method cannot.
-  bool isValidIntOrFloat(int64_t dataEltSize, bool isInt, bool isSigned) const;
 };
 
 /// An attribute that represents a reference to a dense float vector or tensor
 /// object. Each element is stored as a double.
-class DenseFPElementsAttr : public DenseElementsAttr {
+class DenseFPElementsAttr : public DenseIntOrFPElementsAttr {
 public:
   using iterator = DenseElementsAttr::FloatElementIterator;
 
-  using DenseElementsAttr::DenseElementsAttr;
+  using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseFPElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
   static DenseFPElementsAttr get(const ShapedType &type, Arg &&arg) {
     return DenseElementsAttr::get(type, llvm::makeArrayRef(arg))
         .template cast<DenseFPElementsAttr>();
   }
public:
   iterator end() const { return float_value_end(); }
 
   /// Method for supporting type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr);
 };
 
 /// An attribute that represents a reference to a dense integer vector or tensor
 /// object.
-class DenseIntElementsAttr : public DenseElementsAttr {
+class DenseIntElementsAttr : public DenseIntOrFPElementsAttr {
 public:
   /// DenseIntElementsAttr iterates on APInt, so we can use the raw element
   /// iterator directly.
   using iterator = DenseElementsAttr::IntElementIterator;
 
-  using DenseElementsAttr::DenseElementsAttr;
+  using DenseIntOrFPElementsAttr::DenseIntOrFPElementsAttr;
 
   /// Get an instance of a DenseIntElementsAttr with the given arguments. This
   /// simply wraps the DenseElementsAttr::get calls.
   template <typename Arg>
   static DenseIntElementsAttr get(const ShapedType &type, Arg &&arg) {
     return DenseElementsAttr::get(type, llvm::makeArrayRef(arg))
         .template cast<DenseIntElementsAttr>();
   }
class ElementsAttrIterator
   };
 
   /// Utility method to process a functor on each of the internal iterator
   /// types.
   template <typename RetT, template <typename> class ProcessFn,
             typename... Args>
   RetT process(Args &... args) const {
     switch (attrKind) {
-    case StandardAttributes::DenseElements:
+    case StandardAttributes::DenseIntOrFPElements:
       return ProcessFn<DenseIteratorT>()(args...);
     case StandardAttributes::SparseElements:
       return ProcessFn<SparseIteratorT>()(args...);
     }
     llvm_unreachable("unexpected attribute kind");
   }
 
   /// Utility functors used to generically implement the iterators methods.

mlir/include/mlir/IR/OpBase.td

let constBuilderCall = "DenseElementsAttr::get("
     "}, $_builder.getF" # width # "Type()), "
     "llvm::makeArrayRef($0)).cast<DenseFPElementsAttr>()";
   let convertFromStorage = "$_self";
 }
 
 class RankedF32ElementsAttr<list<int> dims> : RankedFloatElementsAttr<32, dims>;
 class RankedF64ElementsAttr<list<int> dims> : RankedFloatElementsAttr<64, dims>;
 
+def StringElementsAttr : ElementsAttrBase<
+  CPred<"$_self.isa<DenseStringElementsAttr>()" >,
+  "string elements attribute"> {
+
+  let storageType = [{ DenseElementsAttr }];
+  let returnType = [{ DenseElementsAttr }];
+
+  let convertFromStorage = "$_self";
+}
+
 // Base class for array attributes.
 class ArrayAttrBase<Pred condition, string description> :
     Attr<condition, description> {
   let storageType = [{ ArrayAttr }];
   let returnType = [{ ArrayAttr }];
   let valueType = NoneType;
   let convertFromStorage = "$_self";
 }

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

static LogicalResult verify(spirv::ConstantOp constOp) {
   case StandardAttributes::Bool:
   case StandardAttributes::Integer:
   case StandardAttributes::Float: {
     if (valueType != opType)
       return constOp.emitOpError("result type (")
              << opType << ") does not match value type (" << valueType << ")";
     return success();
   } break;
-  case StandardAttributes::DenseElements:
+  case StandardAttributes::DenseIntOrFPElements:
   case StandardAttributes::SparseElements: {
     if (valueType == opType)
       break;
     auto arrayType = opType.dyn_cast<spirv::ArrayType>();
     auto shapedType = valueType.dyn_cast<ShapedType>();
     if (!arrayType) {
       return constOp.emitOpError(
           "must have spv.array result type for array value");

mlir/lib/IR/AsmPrinter.cpp

protected:
   void printNamedAttribute(NamedAttribute attr);
   void printTrailingLocation(Location loc);
   void printLocationInternal(LocationAttr loc, bool pretty = false);
 
   /// Print a dense elements attribute. If 'allowHex' is true, a hex string is
   /// used instead of individual elements when the elements attr is large.
   void printDenseElementsAttr(DenseElementsAttr attr, bool allowHex);
 
+  /// Print a dense string elements attribute.
+  void printDenseStringElementsAttr(DenseStringElementsAttr attr);
+
   void printDialectAttribute(Attribute attr);
   void printDialectType(Type type);
 
   /// This enum is used to represent the binding strength of the enclosing
   /// context that an AffineExprStorage is being printed in, so we can
   /// intelligently produce parens.
   enum class BindingStrength {
     Weak,   // + and -
case StandardAttributes::OpaqueElements: {
     if (printerFlags.shouldElideElementsAttr(eltsAttr)) {
       printElidedElementsAttr(os);
       break;
     }
     os << "opaque<\"" << eltsAttr.getDialect()->getNamespace() << "\", ";
     os << '"' << "0x" << llvm::toHex(eltsAttr.getValue()) << "\">";
     break;
   }
-  case StandardAttributes::DenseElements: {
+  case StandardAttributes::DenseIntOrFPElements: {
     auto eltsAttr = attr.cast<DenseElementsAttr>();
     if (printerFlags.shouldElideElementsAttr(eltsAttr)) {
       printElidedElementsAttr(os);
       break;
     }
     os << "dense<";
     printDenseElementsAttr(eltsAttr, /*allowHex=*/true);
     os << '>';
     break;
   }
+  case StandardAttributes::DenseStringElements: {
+    auto eltsAttr = attr.cast<DenseStringElementsAttr>();
+    if (printerFlags.shouldElideElementsAttr(eltsAttr)) {
+      printElidedElementsAttr(os);
+      break;
+    }
+    os << "dense<";
+    printDenseStringElementsAttr(eltsAttr);
+    os << '>';
+    break;
+  }
   case StandardAttributes::SparseElements: {
     auto elementsAttr = attr.cast<SparseElementsAttr>();
     if (printerFlags.shouldElideElementsAttr(elementsAttr.getIndices()) ||
         printerFlags.shouldElideElementsAttr(elementsAttr.getValues())) {
       printElidedElementsAttr(os);
       break;
     }
     os << "sparse<";

 /// Print the float element of the given DenseElementsAttr at 'index'.
 static void printDenseFloatElement(DenseElementsAttr attr, raw_ostream &os,
                                    unsigned index, bool isSigned) {
   assert(isSigned && "floating point values are always signed");
   APFloat value = *std::next(attr.float_value_begin(), index);
   printFloatValue(value, os);
 }
 
+static void printDenseStringElement(DenseStringElementsAttr attr,
+                                    raw_ostream &os, unsigned index) {
+  os << "\"";
+  printEscapedString(attr.getRawStringData()[index], os);
+  os << "\"";
+}
+
 void ModulePrinter::printDenseElementsAttr(DenseElementsAttr attr,
                                            bool allowHex) {
   auto type = attr.getType();
   auto shape = type.getShape();
   auto rank = type.getRank();
   bool isSigned = !type.getElementType().isUnsignedInteger();
 
   // The function used to print elements of this attribute.
for (int i = 0; i < rank; ++i)
       os << '[';
     for (int i = 0; i < rank; ++i)
       os << ']';
     return;
   }
 
   // Check to see if we should format this attribute as a hex string.
   if (allowHex && shouldPrintElementsAttrWithHex(numElements)) {
     ArrayRef<char> rawData = attr.getRawData();
     os << '"' << "0x" << llvm::toHex(StringRef(rawData.data(), rawData.size()))
        << "\"";
     return;
   }
 
   // We use a mixed-radix counter to iterate through the shape. When we bump a
   // non-least-significant digit, we emit a close bracket. When we next emit an
   // element we re-open all closed brackets.
for (unsigned idx = 0, e = numElements; idx != e; ++idx) {
     openBrackets = rank;
     printEltFn(attr, os, idx, isSigned);
     bumpCounter();
   }
   while (openBrackets-- > 0)
     os << ']';
 }
 
+void ModulePrinter::printDenseStringElementsAttr(DenseStringElementsAttr attr) {
+  auto type = attr.getType();
+  auto shape = type.getShape();
+  auto rank = type.getRank();
+
+  // Special case for 0-d and splat tensors.
+  if (attr.isSplat()) {
+    printDenseStringElement(attr, os, 0);
+    return;
+  }
+
+  // Special case for degenerate tensors.
+  auto numElements = type.getNumElements();
+  if (numElements == 0) {
+    for (int i = 0; i < rank; ++i)
+      os << '[';
+    for (int i = 0; i < rank; ++i)
+      os << ']';
+    return;
+  }
+
+  // We use a mixed-radix counter to iterate through the shape. When we bump a
+  // non-least-significant digit, we emit a close bracket. When we next emit an
+  // element we re-open all closed brackets.
+
+  // The mixed-radix counter, with radices in 'shape'.
+  SmallVector<unsigned, 4> counter(rank, 0);
+  // The number of brackets that have been opened and not closed.
+  unsigned openBrackets = 0;
+
+  auto bumpCounter = [&]() {
+    // Bump the least significant digit.
+    ++counter[rank - 1];
+    // Iterate backwards bubbling back the increment.
+    for (unsigned i = rank - 1; i > 0; --i)
+      if (counter[i] >= shape[i]) {
+        // Index 'i' is rolled over. Bump (i-1) and close a bracket.
+        counter[i] = 0;
+        ++counter[i - 1];
+        --openBrackets;
+        os << ']';
+      }
+  };
+
+  for (unsigned idx = 0, e = numElements; idx != e; ++idx) {
+    if (idx != 0)
+      os << ", ";
+    while (openBrackets++ < rank)
+      os << '[';
+    openBrackets = rank;
+    printDenseStringElement(attr, os, idx);
+    bumpCounter();
+  }
+  while (openBrackets-- > 0)
+    os << ']';
+}
+
 void ModulePrinter::printType(Type type) {
   if (!type) {
     os << "<<NULL TYPE>>";
     return;
   }
 
   // Check for an alias for this type.
   if (state) {

mlir/lib/IR/AttributeDetail.h

if (eltType.isBF16())
     return 64;
   if (eltType.isIndex())
     return IndexType::kInternalStorageBitWidth;
   return eltType.getIntOrFloatBitWidth();
 }
 
 /// An attribute representing a reference to a dense vector or tensor object.
 struct DenseElementsAttributeStorage : public AttributeStorage {
+public:
+  DenseElementsAttributeStorage(ShapedType ty, bool isSplat)
+      : AttributeStorage(ty), isSplat(isSplat) {}
+
+  bool isSplat;
+};
+
+/// An attribute representing a reference to a dense vector or tensor object.
+struct DenseIntOrFPElementsAttributeStorage
+    : public DenseElementsAttributeStorage {
+  DenseIntOrFPElementsAttributeStorage(ShapedType ty, ArrayRef<char> data,
+                                       bool isSplat = false)
+      : DenseElementsAttributeStorage(ty, isSplat), data(data) {}
+
   struct KeyTy {
     KeyTy(ShapedType type, ArrayRef<char> data, llvm::hash_code hashCode,
           bool isSplat = false)
         : type(type), data(data), hashCode(hashCode), isSplat(isSplat) {}
 
     /// The type of the dense elements.
     ShapedType type;
 
     /// The raw buffer for the data storage.
     ArrayRef<char> data;
 
     /// The computed hash code for the storage data.
     llvm::hash_code hashCode;
 
     /// A boolean that indicates if this data is a splat or not.
     bool isSplat;
   };
 
-  DenseElementsAttributeStorage(ShapedType ty, ArrayRef<char> data,
-                                bool isSplat = false)
-      : AttributeStorage(ty), data(data), isSplat(isSplat) {}
-
   /// Compare this storage instance with the provided key.
   bool operator==(const KeyTy &key) const {
     if (key.type != getType())
       return false;
 
     // For boolean splats we need to explicitly check that the first bit is the
     // same. Boolean values are packed at the bit level, and even though a splat
     // is detected the rest of the bits in the first byte may differ from the
struct DenseIntOrFPElementsAttributeStorage
   }
 
   /// Hash the key for the storage.
   static llvm::hash_code hashKey(const KeyTy &key) {
     return llvm::hash_combine(key.type, key.hashCode);
   }
 
   /// Construct a new storage instance.
-  static DenseElementsAttributeStorage *
+  static DenseIntOrFPElementsAttributeStorage *
   construct(AttributeStorageAllocator &allocator, KeyTy key) {
     // If the data buffer is non-empty, we copy it into the allocator with a
     // 64-bit alignment.
     ArrayRef<char> copy, data = key.data;
     if (!data.empty()) {
       char *rawData = reinterpret_cast<char *>(
           allocator.allocate(data.size(), alignof(uint64_t)));
       std::memcpy(rawData, data.data(), data.size());
 
       // If this is a boolean splat, make sure only the first bit is used.
       if (key.isSplat && key.type.getElementType().isInteger(1))
         rawData[0] &= 1;
       copy = ArrayRef<char>(rawData, data.size());
     }
 
-    return new (allocator.allocate<DenseElementsAttributeStorage>())
-        DenseElementsAttributeStorage(key.type, copy, key.isSplat);
+    return new (allocator.allocate<DenseIntOrFPElementsAttributeStorage>())
+        DenseIntOrFPElementsAttributeStorage(key.type, copy, key.isSplat);
   }
 
   ArrayRef<char> data;
+};
+
+/// An attribute representing a reference to a dense vector or tensor object
+/// containing strings.
+struct DenseStringElementsAttributeStorage
+    : public DenseElementsAttributeStorage {
+  DenseStringElementsAttributeStorage(ShapedType ty, ArrayRef<StringRef> data,
+                                      bool isSplat = false)
+      : DenseElementsAttributeStorage(ty, isSplat), data(data) {}
+
+  struct KeyTy {
+    KeyTy(ShapedType type, ArrayRef<StringRef> data, llvm::hash_code hashCode,
+          bool isSplat = false)
+        : type(type), data(data), hashCode(hashCode), isSplat(isSplat) {}
+
+    /// The type of the dense elements.
+    ShapedType type;
+
+    /// The raw buffer for the data storage.
+    ArrayRef<StringRef> data;
+
+    /// The computed hash code for the storage data.
+    llvm::hash_code hashCode;
+
+    /// A boolean that indicates if this data is a splat or not.
     bool isSplat;
   };
 
+  /// Compare this storage instance with the provided key.
+  bool operator==(const KeyTy &key) const {
+    if (key.type != getType())
+      return false;
+
+    // Otherwise, we can default to just checking the data. StringRefs compare
+    // by contents.
+    return key.data == data;
+  }
+
+  /// Construct a key from a shaped type, StringRef data buffer, and a flag that
+  /// signals if the data is already known to be a splat. Callers to this
+  /// function are expected to tag preknown splat values when possible, e.g. one
+  /// element shapes.
+  static KeyTy getKey(ShapedType ty, ArrayRef<StringRef> data,
+                      bool isKnownSplat) {
+    // Handle an empty storage instance.
+    if (data.empty())
+      return KeyTy(ty, data, 0);
+
+    // If the data is already known to be a splat, the key hash value is
+    // directly the data buffer.
+    if (isKnownSplat)
+      return KeyTy(ty, data, llvm::hash_value(data), isKnownSplat);
+
+    // Handle the simple case of only one element.
+    size_t numElements = ty.getNumElements();
+    assert(numElements != 1 && "splat of 1 element should already be detected");
+
+    // Create the initial hash value with just the first element.
+    const auto &firstElt = data.front();
+    auto hashVal = llvm::hash_value(firstElt);
+
+    // Check to see if this storage represents a splat. If it doesn't then
+    // combine the hash for the data starting with the first non splat element.
+    for (size_t i = 1, e = data.size(); i != e; i++)
+      if (!firstElt.equals(data[i]))
+        return KeyTy(ty, data, llvm::hash_combine(hashVal, data.drop_front(i)));
+
+    // Otherwise, this is a splat so just return the hash of the first element.
+    return KeyTy(ty, {firstElt}, hashVal, /*isSplat=*/true);
+  }
+
+  /// Hash the key for the storage.
+  static llvm::hash_code hashKey(const KeyTy &key) {
+    return llvm::hash_combine(key.type, key.hashCode);
+  }
+
+  /// Construct a new storage instance.
+  static DenseStringElementsAttributeStorage *
+  construct(AttributeStorageAllocator &allocator, KeyTy key) {
+    // If the data buffer is non-empty, we copy it into the allocator with a
+    // 64-bit alignment.
+    ArrayRef<StringRef> copy, data = key.data;
+    if (data.empty()) {
+      return new (allocator.allocate<DenseStringElementsAttributeStorage>())
+          DenseStringElementsAttributeStorage(key.type, copy, key.isSplat);
+    }
+
+    int numEntries = key.isSplat ? 1 : data.size();
+
+    // Compute the amount data needed to store the ArrayRef and StringRef
+    // contents.
+    size_t dataSize = sizeof(StringRef) * numEntries;
+    for (int i = 0; i < numEntries; i++)
+      dataSize += data[i].size();
+
+    char *rawData = reinterpret_cast<char *>(
+        allocator.allocate(dataSize, alignof(uint64_t)));
+
+    // Setup a mutable array ref of our string refs so that we can update their
+    // contents.
+    auto mutableCopy = MutableArrayRef<StringRef>(
+        reinterpret_cast<StringRef *>(rawData), numEntries);
+    auto stringData = rawData + numEntries * sizeof(StringRef);
+
+    for (int i = 0; i < numEntries; i++) {
+      memcpy(stringData, data[i].data(), data[i].size());
+      mutableCopy[i] = StringRef(stringData, data[i].size());
+      stringData += data[i].size();
+    }
+
+    copy =
+        ArrayRef<StringRef>(reinterpret_cast<StringRef *>(rawData), numEntries);
+
+    return new (allocator.allocate<DenseStringElementsAttributeStorage>())
+        DenseStringElementsAttributeStorage(key.type, copy, key.isSplat);
+  }
+
+  ArrayRef<StringRef> data;
+};
+
 /// An attribute representing a reference to a tensor constant with opaque
 /// content.
 struct OpaqueElementsAttributeStorage : public AttributeStorage {
   using KeyTy = std::tuple<Type, Dialect *, StringRef>;
 
   OpaqueElementsAttributeStorage(Type type, Dialect *dialect, StringRef bytes)
       : AttributeStorage(type), dialect(dialect), bytes(bytes) {}
 

mlir/lib/IR/Attributes.cpp

 int64_t ElementsAttr::getNumElements() const {
   return getType().getNumElements();
 }
 
 /// Return the value at the given index. If index does not refer to a valid
 /// element, then a null attribute is returned.
 Attribute ElementsAttr::getValue(ArrayRef<uint64_t> index) const {
   switch (getKind()) {
-  case StandardAttributes::DenseElements:
+  case StandardAttributes::DenseIntOrFPElements:
     return cast<DenseElementsAttr>().getValue(index);
   case StandardAttributes::OpaqueElements:
     return cast<OpaqueElementsAttr>().getValue(index);
   case StandardAttributes::SparseElements:
     return cast<SparseElementsAttr>().getValue(index);
   default:
     llvm_unreachable("unknown ElementsAttr kind");
   }
return llvm::all_of(llvm::seq<int>(0, rank), [&](int i) {
     return static_cast<int64_t>(index[i]) < shape[i];
   });
 }
 
 ElementsAttr
 ElementsAttr::mapValues(Type newElementType,
                         function_ref<APInt(const APInt &)> mapping) const {
   switch (getKind()) {
-  case StandardAttributes::DenseElements:
+  case StandardAttributes::DenseIntOrFPElements:
     return cast<DenseElementsAttr>().mapValues(newElementType, mapping);
   default:
     llvm_unreachable("unsupported ElementsAttr subtype");
   }
 }
 
 ElementsAttr
 ElementsAttr::mapValues(Type newElementType,
                         function_ref<APInt(const APFloat &)> mapping) const {
   switch (getKind()) {
-  case StandardAttributes::DenseElements:
+  case StandardAttributes::DenseIntOrFPElements:
     return cast<DenseElementsAttr>().mapValues(newElementType, mapping);
   default:
     llvm_unreachable("unsupported ElementsAttr subtype");
   }
 }
 
 /// Returns the 1 dimensional flattened row-major index from the given
 /// multi-dimensional index.
case StandardTypes::Index:
       break;
     default:
       llvm_unreachable("unexpected element type");
     }
     assert(intVal.getBitWidth() == bitWidth &&
            "expected value to have same bitwidth as element type");
     writeBits(data.data(), i * storageBitWidth, intVal);
   }
-  return getRaw(type, data, /*isSplat=*/(values.size() == 1));
+  return DenseIntOrFPElementsAttr::getRaw(type, data,
+                                          /*isSplat=*/(values.size() == 1));
 }
 
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<bool> values) {
   assert(hasSameElementsOrSplat(type, values));
   assert(type.getElementType().isInteger(1));
 
   std::vector<char> buff(llvm::divideCeil(values.size(), CHAR_BIT));
   for (int i = 0, e = values.size(); i != e; ++i)
     setBit(buff.data(), i, values[i]);
-  return getRaw(type, buff, /*isSplat=*/(values.size() == 1));
+  return DenseIntOrFPElementsAttr::getRaw(type, buff,
+                                          /*isSplat=*/(values.size() == 1));
+}
+
+DenseElementsAttr DenseElementsAttr::get(ShapedType type,
+                                         ArrayRef<StringRef> values) {
+  assert(!type.getElementType().isIntOrFloat());
+  return DenseStringElementsAttr::get(type, values);
 }
 
 /// Constructs a dense integer elements attribute from an array of APInt
 /// values. Each APInt value is expected to have the same bitwidth as the
 /// element type of 'type'.
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<APInt> values) {
   assert(type.getElementType().isIntOrIndex());
-  return getRaw(type, values);
+  return DenseIntOrFPElementsAttr::getRaw(type, values);
 }
 
 // Constructs a dense float elements attribute from an array of APFloat
 // values. Each APFloat value is expected to have the same bitwidth as the
 // element type of 'type'.
 DenseElementsAttr DenseElementsAttr::get(ShapedType type,
                                          ArrayRef<APFloat> values) {
   assert(type.getElementType().isa<FloatType>());
 
   // Convert the APFloat values to APInt and create a dense elements attribute.
   std::vector<APInt> intValues(values.size());
   for (unsigned i = 0, e = values.size(); i != e; ++i)
     intValues[i] = values[i].bitcastToAPInt();
-  return getRaw(type, intValues);
+  return DenseIntOrFPElementsAttr::getRaw(type, intValues);
 }
 
 /// Construct a dense elements attribute from a raw buffer representing the
 /// data for this attribute. Users should generally not use this methods as
 /// the expected buffer format may not be a form the user expects.
 DenseElementsAttr DenseElementsAttr::getFromRawBuffer(ShapedType type,
                                                       ArrayRef<char> rawBuffer,
                                                       bool isSplatBuffer) {
-  return getRaw(type, rawBuffer, isSplatBuffer);
-}
-
-/// Constructs a dense elements attribute from an array of raw APInt values.
-/// Each APInt value is expected to have the same bitwidth as the element type
-/// of 'type'.
-DenseElementsAttr DenseElementsAttr::getRaw(ShapedType type,
-                                            ArrayRef<APInt> values) {
-  assert(hasSameElementsOrSplat(type, values));
-
-  size_t bitWidth = getDenseElementBitWidth(type.getElementType());
-  size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
-  std::vector<char> elementData(llvm::divideCeil(storageBitWidth, CHAR_BIT) *
-                                values.size());
-  for (unsigned i = 0, e = values.size(); i != e; ++i) {
-    assert(values[i].getBitWidth() == bitWidth);
-    writeBits(elementData.data(), i * storageBitWidth, values[i]);
-  }
-  return getRaw(type, elementData, /*isSplat=*/(values.size() == 1));
-}
-
-DenseElementsAttr DenseElementsAttr::getRaw(ShapedType type,
-                                            ArrayRef<char> data, bool isSplat) {
-  assert((type.isa<RankedTensorType>() || type.isa<VectorType>()) &&
-         "type must be ranked tensor or vector");
-  assert(type.hasStaticShape() && "type must have static shape");
-  return Base::get(type.getContext(), StandardAttributes::DenseElements, type,
-                   data, isSplat);
+  return DenseIntOrFPElementsAttr::getRaw(type, rawBuffer, isSplatBuffer);
 }
 
 /// Check the information for a C++ data type, check if this type is valid for
 /// the current attribute. This method is used to verify specific type
 /// invariants that the templatized 'getValues' method cannot.
 static bool isValidIntOrFloat(ShapedType type, int64_t dataEltSize, bool isInt,
                               bool isSigned) {
   // Make sure that the data element size is the same as the type element width.
if (!intType)
     return false;
 
   // Make sure signedness semantics is consistent.
   if (intType.isSignless())
     return true;
   return intType.isSigned() ? isSigned : !isSigned;
 }
 
-/// Overload of the 'getRaw' method that asserts that the given type is of
-/// integer type. This method is used to verify type invariants that the
-/// templatized 'get' method cannot.
+/// Defaults down the subclass implementation.
 DenseElementsAttr DenseElementsAttr::getRawIntOrFloat(ShapedType type,
                                                       ArrayRef<char> data,
                                                       int64_t dataEltSize,
                                                       bool isInt,
                                                       bool isSigned) {
-  assert(::isValidIntOrFloat(type, dataEltSize, isInt, isSigned));
-
-  int64_t numElements = data.size() / dataEltSize;
-  assert(numElements == 1 || numElements == type.getNumElements());
-  return getRaw(type, data, /*isSplat=*/numElements == 1);
+  return DenseIntOrFPElementsAttr::getRawIntOrFloat(type, data, dataEltSize,
+                                                    isInt, isSigned);
 }
 
 /// A method used to verify specific type invariants that the templatized 'get'
 /// method cannot.
 bool DenseElementsAttr::isValidIntOrFloat(int64_t dataEltSize, bool isInt,
                                           bool isSigned) const {
   return ::isValidIntOrFloat(getType(), dataEltSize, isInt, isSigned);
 }
 
 /// Returns if this attribute corresponds to a splat, i.e. if all element
 /// values are the same.
-bool DenseElementsAttr::isSplat() const { return getImpl()->isSplat; }
+bool DenseElementsAttr::isSplat() const {
+  return static_cast<DenseElementsAttributeStorage *>(impl)->isSplat;
+}
 
 /// Return the held element values as a range of Attributes.
 auto DenseElementsAttr::getAttributeValues() const
     -> llvm::iterator_range<AttributeElementIterator> {
   return {attr_value_begin(), attr_value_end()};
 }
 auto DenseElementsAttr::attr_value_begin() const -> AttributeElementIterator {
   return AttributeElementIterator(*this, 0);
auto DenseElementsAttr::float_value_begin() const -> FloatElementIterator {
   return getFloatValues().begin();
 }
 auto DenseElementsAttr::float_value_end() const -> FloatElementIterator {
   return getFloatValues().end();
 }
 
 /// Return the raw storage data held by this attribute.
 ArrayRef<char> DenseElementsAttr::getRawData() const {
-  return static_cast<ImplType *>(impl)->data;
+  return static_cast<DenseIntOrFPElementsAttributeStorage *>(impl)->data;
+}
+
+ArrayRef<StringRef> DenseElementsAttr::getRawStringData() const {
+  return static_cast<DenseStringElementsAttributeStorage *>(impl)->data;
 }
 
 /// Return a new DenseElementsAttr that has the same data as the current
 /// attribute, but has been reshaped to 'newType'. The new type must have the
 /// same total number of elements as well as element type.
 DenseElementsAttr DenseElementsAttr::reshape(ShapedType newType) {
   ShapedType curType = getType();
   if (curType == newType)
     return *this;
 
   (void)curType;
   assert(newType.getElementType() == curType.getElementType() &&
          "expected the same element type");
   assert(newType.getNumElements() == curType.getNumElements() &&
          "expected the same number of elements");
-  return getRaw(newType, getRawData(), isSplat());
+  return DenseIntOrFPElementsAttr::getRaw(newType, getRawData(), isSplat());
 }
 
 DenseElementsAttr
 DenseElementsAttr::mapValues(Type newElementType,
                              function_ref<APInt(const APInt &)> mapping) const {
   return cast<DenseIntElementsAttr>().mapValues(newElementType, mapping);
 }
 
 DenseElementsAttr DenseElementsAttr::mapValues(
     Type newElementType, function_ref<APInt(const APFloat &)> mapping) const {
   return cast<DenseFPElementsAttr>().mapValues(newElementType, mapping);
 }
 
 //===----------------------------------------------------------------------===//
+// DenseStringElementsAttr
+//===----------------------------------------------------------------------===//
+
+DenseStringElementsAttr
+DenseStringElementsAttr::get(ShapedType type, ArrayRef<StringRef> values) {
+  return Base::get(type.getContext(), StandardAttributes::DenseStringElements,
+                   type, values, (values.size() == 1));
+}
+
+//===----------------------------------------------------------------------===//
+// DenseIntOrFPElementsAttr
+//===----------------------------------------------------------------------===//
+
+/// Constructs a dense elements attribute from an array of raw APInt values.
+/// Each APInt value is expected to have the same bitwidth as the element type
+/// of 'type'.
+DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
+                                                   ArrayRef<APInt> values) {
+  assert(hasSameElementsOrSplat(type, values));
+
+  size_t bitWidth = getDenseElementBitWidth(type.getElementType());
+  size_t storageBitWidth = getDenseElementStorageWidth(bitWidth);
+  std::vector<char> elementData(llvm::divideCeil(storageBitWidth, CHAR_BIT) *
+                                values.size());
+  for (unsigned i = 0, e = values.size(); i != e; ++i) {
+    assert(values[i].getBitWidth() == bitWidth);
+    writeBits(elementData.data(), i * storageBitWidth, values[i]);
+  }
+  return DenseIntOrFPElementsAttr::getRaw(type, elementData,
+                                          /*isSplat=*/(values.size() == 1));
+}
+
+DenseElementsAttr DenseIntOrFPElementsAttr::getRaw(ShapedType type,
+                                                   ArrayRef<char> data,
+                                                   bool isSplat) {
+  assert((type.isa<RankedTensorType>() || type.isa<VectorType>()) &&
+         "type must be ranked tensor or vector");
+  assert(type.hasStaticShape() && "type must have static shape");
+  return Base::get(type.getContext(), StandardAttributes::DenseIntOrFPElements,
+                   type, data, isSplat);
+}
+
+/// Overload of the 'getRaw' method that asserts that the given type is of
+/// integer type. This method is used to verify type invariants that the
+/// templatized 'get' method cannot.
+DenseElementsAttr
+DenseIntOrFPElementsAttr::getRawIntOrFloat(ShapedType type, ArrayRef<char> data,
+                                           int64_t dataEltSize, bool isInt,
+                                           bool isSigned) {
+  assert(::isValidIntOrFloat(type, dataEltSize, isInt, isSigned));
+
+  int64_t numElements = data.size() / dataEltSize;
+  assert(numElements == 1 || numElements == type.getNumElements());
+  return getRaw(type, data, /*isSplat=*/numElements == 1);
+}
+
+//===----------------------------------------------------------------------===//
 // DenseFPElementsAttr
 //===----------------------------------------------------------------------===//
 
 template <typename Fn, typename Attr>
 static ShapedType mappingHelper(Fn mapping, Attr &attr, ShapedType inType,
                                 Type newElementType,
                                 llvm::SmallVectorImpl<char> &data) {
   size_t bitWidth = getDenseElementBitWidth(newElementType);

mlir/lib/IR/MLIRContext.cpp

 // Builtin Dialect
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// A builtin dialect to define types/etc that are necessary for the validity of
 /// the IR.
 struct BuiltinDialect : public Dialect {
   BuiltinDialect(MLIRContext *context) : Dialect(/*name=*/"", context) {
-    addAttributes<AffineMapAttr, ArrayAttr, BoolAttr, DenseElementsAttr,
-                  DictionaryAttr, FloatAttr, SymbolRefAttr, IntegerAttr,
-                  IntegerSetAttr, OpaqueAttr, OpaqueElementsAttr,
-                  SparseElementsAttr, StringAttr, TypeAttr, UnitAttr>();
+    addAttributes<AffineMapAttr, ArrayAttr, BoolAttr, DenseIntOrFPElementsAttr,
+                  DenseStringElementsAttr, DictionaryAttr, FloatAttr,
+                  SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
+                  OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
+                  UnitAttr>();
     addAttributes<CallSiteLoc, FileLineColLoc, FusedLoc, NameLoc, OpaqueLoc,
                   UnknownLoc>();
 
     addTypes<ComplexType, FloatType, FunctionType, IndexType, IntegerType,
              MemRefType, UnrankedMemRefType, NoneType, OpaqueType,
              RankedTensorType, TupleType, UnrankedTensorType, VectorType>();
 
     // TODO: These operations should be moved to a different dialect when they

mlir/lib/Parser/Parser.cpp

public:
 
   /// Build a dense attribute instance with the parsed elements and the given
   /// shaped type.
   DenseElementsAttr getAttr(llvm::SMLoc loc, ShapedType type);
 
   ArrayRef<int64_t> getShape() const { return shape; }
 
 private:
-  enum class ElementKind { Boolean, Integer, Float };
+  enum class ElementKind { Boolean, Integer, Float, String };
 
   /// Return a string to represent the given element kind.
   const char *getElementKindStr(ElementKind kind) {
     switch (kind) {
     case ElementKind::Boolean:
       return "'boolean'";
     case ElementKind::Integer:
       return "'integer'";
     case ElementKind::Float:
       return "'float'";
+    case ElementKind::String:
+      return "'string'";
     }
     llvm_unreachable("unknown element kind");
   }
 
   /// Build a Dense Integer attribute for the given type.
   DenseElementsAttr getIntAttr(llvm::SMLoc loc, ShapedType type, Type eltTy);
 
   /// Build a Dense Float attribute for the given type.
   DenseElementsAttr getFloatAttr(llvm::SMLoc loc, ShapedType type,
                                  FloatType eltTy);
 
+  /// Build a Dense String attribute for the given type.
+  DenseElementsAttr getStringAttr(llvm::SMLoc loc, ShapedType type, Type eltTy);
+
   /// Build a Dense attribute with hex data for the given type.
   DenseElementsAttr getHexAttr(llvm::SMLoc loc, ShapedType type);
 
   /// Parse a single element, returning failure if it isn't a valid element
   /// literal. For example:
   /// parseElement(1) -> Success, 1
   /// parseElement([1]) -> Failure
   ParseResult parseElement();
if (p.getToken().is(Token::l_square))
     return parseList(shape);
   return parseElement();
 }
 
 /// Build a dense attribute instance with the parsed elements and the given
 /// shaped type.
 DenseElementsAttr TensorLiteralParser::getAttr(llvm::SMLoc loc,
                                                ShapedType type) {
-  // Check to see if we parsed the literal from a hex string.
-  if (hexStorage.hasValue())
+  Type eltType = type.getElementType();
+
+  // Check to see if we parse the literal from a hex string.
+  if (hexStorage.hasValue() && eltType.isIntOrFloat())
     return getHexAttr(loc, type);
 
   // Check that the parsed storage size has the same number of elements to the
   // type, or is a known splat.
   if (!shape.empty() && getShape() != type.getShape()) {
     p.emitError(loc) << "inferred shape of elements literal ([" << getShape()
                      << "]) does not match type ([" << type.getShape() << "])";
     return nullptr;
   }
 
   // If the type is an integer, build a set of APInt values from the storage
   // with the correct bitwidth.
-  Type eltType = type.getElementType();
   if (auto intTy = eltType.dyn_cast<IntegerType>())
     return getIntAttr(loc, type, intTy);
   if (auto indexTy = eltType.dyn_cast<IndexType>())
     return getIntAttr(loc, type, indexTy);
 
-  // Otherwise, this must be a floating point type.
-  auto floatTy = eltType.dyn_cast<FloatType>();
-  if (!floatTy) {
-    p.emitError(loc) << "expected floating-point or integer element type, got "
-                     << eltType;
-    return nullptr;
-  }
+  // If parsing a floating point type.
+  if (auto floatTy = eltType.dyn_cast<FloatType>())
     return getFloatAttr(loc, type, floatTy);
+
+  // Other types are assumed to be string representations.
+  return getStringAttr(loc, type, type.getElementType());
 }
 
 /// Build a Dense Integer attribute for the given type.
 DenseElementsAttr TensorLiteralParser::getIntAttr(llvm::SMLoc loc,
                                                   ShapedType type, Type eltTy) {
   std::vector<APInt> intElements;
   intElements.reserve(storage.size());
   auto isUintType = type.getElementType().isUnsignedInteger();
if (!eltTy.isBF16() && !eltTy.isF64()) {
                     &unused);
     }
     floatValues.push_back(apVal);
   }
 
   return DenseElementsAttr::get(type, floatValues);
 }
 
+/// Build a Dense String attribute for the given type.
+DenseElementsAttr TensorLiteralParser::getStringAttr(llvm::SMLoc loc,
+                                                     ShapedType type,
+                                                     Type eltTy) {
+  if (hexStorage.hasValue()) {
+    auto stringValue = hexStorage.getValue().getStringValue();
+    return DenseStringElementsAttr::get(type, {stringValue});
+  }
+
+  std::vector<std::string> stringValues;
+  std::vector<StringRef> stringRefValues;
+  stringValues.reserve(storage.size());
+  stringRefValues.reserve(storage.size());
+
+  for (auto val : storage) {
+    stringValues.push_back(val.second.getStringValue());
+    stringRefValues.push_back(stringValues.back());
+  }
+
+  return DenseStringElementsAttr::get(type, stringRefValues);
+}
+
 /// Build a Dense attribute with hex data for the given type.
 DenseElementsAttr TensorLiteralParser::getHexAttr(llvm::SMLoc loc,
                                                   ShapedType type) {
   Type elementType = type.getElementType();
   if (!elementType.isa<FloatType>() && !elementType.isa<IntegerType>()) {
     p.emitError(loc) << "expected floating-point or integer element type, got "
                      << elementType;
     return nullptr;
ParseResult TensorLiteralParser::parseElement() {
   case Token::minus:
     p.consumeToken(Token::minus);
     if (!p.getToken().isAny(Token::floatliteral, Token::integer))
       return p.emitError("expected integer or floating point literal");
     storage.emplace_back(/*isNegative=*/true, p.getToken());
     p.consumeToken();
     break;
 
+  case Token::string:
+    storage.emplace_back(/*isNegative=*/ false, p.getToken());
+    p.consumeToken();
+    break;
   default:
     return p.emitError("expected element literal of primitive type");
   }
 
   return success();
 }
 
 /// Parse a list of either lists or elements, returning the dimensions of the
ParseResult TensorLiteralParser::parseList(SmallVectorImpl<int64_t> &dims) {
   dims.push_back(size);
   dims.append(newDims.begin(), newDims.end());
   return success();
 }
 
 /// Parse a dense elements attribute.
 Attribute Parser::parseDenseElementsAttr(Type attrType) {
   consumeToken(Token::kw_dense);
   if (parseToken(Token::less, "expected '<' after 'dense'"))
     return nullptr;
 
   // Parse the literal data.
   TensorLiteralParser literalParser(*this);
   if (literalParser.parse(/*allowHex=*/true))
     return nullptr;
 
   if (parseToken(Token::greater, "expected '>'"))
     return nullptr;

mlir/test/IR/attribute.mlir

"test.float_elements_attr"() {
     tensor_f64_attr = dense<6.0> : tensor<4xf64>
   } : () -> ()
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// Test StringElementsAttr
+//===----------------------------------------------------------------------===//
+
+func @simple_scalar_example() {
+  "test.string_elements_attr"() {
+    // CHECK: dense<"example">
+    scalar_string_attr = dense<"example"> : tensor<2x!unknown<"">>
+  } : () -> ()
+  return
+}
+
+// -----
+
+func @escape_string_example() {
+  "test.string_elements_attr"() {
+    // CHECK: dense<"new\0Aline">
+    scalar_string_attr = dense<"new\nline"> : tensor<2x!unknown<"">>
+  } : () -> ()
+  return
+}
+
+// -----
+
+func @simple_scalar_example() {
+  "test.string_elements_attr"() {
+    // CHECK: dense<["example1", "example2"]>
+    scalar_string_attr = dense<["example1", "example2"]> : tensor<2x!unknown<"">>
+  } : () -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // Test SymbolRefAttr
 //===----------------------------------------------------------------------===//
 
 func @fn() { return }
 
 // CHECK: test.symbol_ref_attr
 "test.symbol_ref_attr"() {symbol = @fn} : () -> ()
 

mlir/test/IR/dense-elements-hex.mlir

 
 // -----
 
 // expected-error@+1 {{elements hex string only contains hex digits}}
 "foo.op"() {dense.attr = dense<"0x0000000000002440000000000000144X"> : tensor<2xf64>} : () -> ()
 
 // -----
 
-// expected-error@+1 {{expected floating-point or integer element type, got '!unknown<"">'}}
-"foo.op"() {dense.attr = dense<"0x00000000000024400000000000001440"> : tensor<2x!unknown<"">>} : () -> ()
-
-// -----
-
 // expected-error@+1 {{elements hex data size is invalid for provided type}}
 "foo.op"() {dense.attr = dense<"0x00000000000024400000000000001440"> : tensor<4xf64>} : () -> ()

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

def DerivedTypeAttrOp : TEST_Op<"derived_type_attr", []> {
   let results = (outs AnyTensor:$output);
   DerivedTypeAttr element_dtype =
     DerivedTypeAttr<"return getElementTypeOrSelf(output().getType());">;
   DerivedAttr size = DerivedAttr<"int",
     "return output().getType().cast<ShapedType>().getSizeInBits();",
     "$_builder.getI32IntegerAttr($_self)">;
 }
 
+def StringElementsAttrOp : TEST_Op<"string_elements_attr"> {
+  let arguments = (ins
+      StringElementsAttr:$scalar_string_attr
+  );
+}
+
 //===----------------------------------------------------------------------===//
 // Test Attribute Constraints
 //===----------------------------------------------------------------------===//
 
 def SymbolRefOp : TEST_Op<"symbol_ref_attr"> {
   let arguments = (ins
     Confined<FlatSymbolRefAttr, [ReferToOp<"FuncOp">]>:$symbol
   );