Sparse String Elements support.

[rsuderman]

Summary

Added support for sparse strings elements. This is a follow up from the original DenseStringElements.

[rriddle]

You also need to add a SparseElementsAttr::getZeroValue<StringRef> so that getValues<T> works:
https://github.com/llvm/llvm-project/blob/5339029ff79c0b6a501ef6bb7baeb07cb099f0b7/mlir/include/mlir/IR/Attributes.h#L1257

mlir/lib/IR/AsmPrinter.cpp

1491

Use cast here as it is guaranteed to be DenseIntOrFPElementsAttr, dyn_cast implies that it may return null.

[rsuderman]

Added getZeroValue() for string.

[rsuderman]

Inserted missing newline.

[rriddle]

mlir/include/mlir/IR/Attributes.h

1255 ↗

(On Diff #260048)

You can just inline this in the getZeroValue<StringRef> below. The other methods are only defined like this because the values can't be constructed inline in the header file.

1282 ↗

(On Diff #260048)

This needs to be a SFINAE template to avoid having ambiguous methods.

1283 ↗

(On Diff #260048)

nit: Newline before here.

[rsuderman]

Removed unneeded helper function.

mlir/lib/IR/AsmPrinter.cpp

protected:
 
   /// 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);
 
+  /// 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 printDenseIntOrFPElementsAttr(DenseIntOrFPElementsAttr attr,
+                                     bool allowHex);
+
   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 -
if (printerFlags.shouldElideElementsAttr(eltsAttr)) {
       printElidedElementsAttr(os);
       break;
     }
     os << "opaque<\"" << eltsAttr.getDialect()->getNamespace() << "\", ";
     os << '"' << "0x" << llvm::toHex(eltsAttr.getValue()) << "\">";
     break;
   }
   case StandardAttributes::DenseIntOrFPElements: {
-    auto eltsAttr = attr.cast<DenseElementsAttr>();
+    auto eltsAttr = attr.cast<DenseIntOrFPElementsAttr>();
     if (printerFlags.shouldElideElementsAttr(eltsAttr)) {
       printElidedElementsAttr(os);
       break;
     }
     os << "dense<";
-    printDenseElementsAttr(eltsAttr, /*allowHex=*/true);
+    printDenseIntOrFPElementsAttr(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<";
-    printDenseElementsAttr(elementsAttr.getIndices(), /*allowHex=*/false);
+    printDenseIntOrFPElementsAttr(elementsAttr.getIndices(),
+                                  /*allowHex=*/false);
     os << ", ";
     printDenseElementsAttr(elementsAttr.getValues(), /*allowHex=*/true);
     os << '>';
     break;
   }
 
   // Location attributes.
   case StandardAttributes::CallSiteLocation:
static void printDenseStringElement(DenseStringElementsAttr attr,
                                     raw_ostream &os, unsigned index) {
   os << "\"";
   printEscapedString(attr.getRawStringData()[index], os);
   os << "\"";
 }
 
 void ModulePrinter::printDenseElementsAttr(DenseElementsAttr attr,
                                            bool allowHex) {
+  if (auto stringAttr = attr.dyn_cast<DenseStringElementsAttr>()) {
+    printDenseStringElementsAttr(stringAttr);
+    return;
+  }
+
+  auto numAttr = attr.dyn_cast<DenseIntOrFPElementsAttr>();
+  printDenseIntOrFPElementsAttr(numAttr, allowHex);
+}
+
+void ModulePrinter::printDenseIntOrFPElementsAttr(DenseIntOrFPElementsAttr 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.
   auto printEltFn = type.getElementType().isIntOrIndex()
                         ? printDenseIntElement

mlir/test/IR/parser.mlir

 // CHECK: "foof32"() {bar = sparse<{{\[}}], {{\[}}]> : tensor<1x0x1xf32>} : () -> ()
   "foof32"(){bar = sparse<[], []> : tensor<1x0x1xf32>} : () -> ()
 // CHECK:  "foof64"() {bar = sparse<0, -1.000000e+00> : tensor<1xf64>} : () -> ()
   "foof64"(){bar = sparse<[[0]], [-1.0]> : tensor<1xf64>} : () -> ()
 // CHECK: "foof320"() {bar = sparse<{{\[}}], {{\[}}]> : tensor<0xf32>} : () -> ()
   "foof320"(){bar = sparse<[], []> : tensor<0xf32>} : () -> ()
 // CHECK: "foof321"() {bar = sparse<{{\[}}], {{\[}}]> : tensor<f32>} : () -> ()
   "foof321"(){bar = sparse<[], []> : tensor<f32>} : () -> ()
+
+// CHECK: "foostr"() {bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<"">>} : () -> ()
+  "foostr"(){bar = sparse<0, "foo"> : tensor<1x1x1x!unknown<"">>} : () -> ()
+// CHECK: "foostr"() {bar = sparse<{{\[\[}}1, 1, 0], {{\[}}0, 1, 0], {{\[}}0, 0, 1]], {{\[}}"a", "b", "c"]> : tensor<2x2x2x!unknown<"">>} : () -> ()
+  "foostr"(){bar = sparse<[[1, 1, 0], [0, 1, 0], [0, 0, 1]], ["a", "b", "c"]> : tensor<2x2x2x!unknown<"">>} : () -> ()
   return
 }
 
 // CHECK-LABEL: func @sparsevectorattr
 func @sparsevectorattr() -> () {
 ^bb0:
 // NOTE: The {{\[\[}} syntax is because "[[" confuses FileCheck.
 // CHECK: "fooi8"() {bar = sparse<0, -2> : vector<1x1x1xi8>} : () -> ()