[mlir] Remove OpaqueElementsAttr

[rriddle]

Summary

This attribute is technical debt from the early stages of MLIR, before
ElementsAttr was an interface and when it was more difficult for
dialects to define their own types of attributes. At present it isn't
used at all in tree (aside from being convenient for eliding other
ElementsAttr), and has had little to no evolution in the past three years.

[jpienaar]

Nice clean-up, keyword freed up too.

mlir/test/CAPI/ir.c

469

Anyway to still retain marker that elided? (I played around in a follow up of my outline constants patch where I used alias mechanism ... Mmm we could have an ElidedAttribute that implements the ElementsAttr but has only shape, just concerned about not being able to differentiate between a real and elided value.

[rriddle]

mlir/test/CAPI/ir.c

469

I agree that it is a bit of a loss from the previous behavior in some aspects, but I'm -1 to having an attribute just for elision. I thought about this a bit when drafting this commit, but it just isn't the right direction. For one, the attribute would have no purpose other than for a special textual mode (which is weird in and of itself), and I don't think we'd add something special for any of the other types of attributes if we wanted to elide them. Also, the previous behavior wrongly assumed that all uses of DenseElementsAttr/SparseElementsAttr could be changed to OpaqueElementsAttr. We have just gotten lucky that the cases we have generally elided were okay with any ElementsAttr attribute.

[mehdi_amini]

I am concerned about turning elided constant into splat right now: this breaks reproducibility in a way that is too subtle and error prone as far as I understand it.

[mehdi_amini]

Have you already thought of alternatives for it?

[rriddle]

In D129917#3659532, @mehdi_amini wrote:

Have you already thought of alternatives for it?

No, but this is not a strong enough justification to warrant keeping it. I don't think we should have an attribute solely for elision, so we don't have a huge number of options right now.

[mehdi_amini]

In D129917#3659550, @rriddle wrote:

In D129917#3659532, @mehdi_amini wrote:

Have you already thought of alternatives for it?

No, but this is not a strong enough justification to warrant keeping it. I don't think we should have an attribute solely for elision, so we don't have a huge number of options right now.

I don't necessarily disagree with you that we may not want to keep an attribute for this purpose (even though that's debatable). I disagree however in that the motivation to remove it is enough to degrade the elision feature in this way right now: I don't think the new behavior is OK.

[rriddle]

In D129917#3660013, @mehdi_amini wrote:

In D129917#3659550, @rriddle wrote:

In D129917#3659532, @mehdi_amini wrote:

Have you already thought of alternatives for it?

No, but this is not a strong enough justification to warrant keeping it. I don't think we should have an attribute solely for elision, so we don't have a huge number of options right now.

I don't necessarily disagree with you that we may not want to keep an attribute for this purpose (even though that's debatable). I disagree however in that the motivation to remove it is enough to degrade the elision feature in this way right now: I don't think the new behavior is OK.

Should we drop the ability to run elided IR then? What do you have in mind? I'm strongly against keeping this just for elision, especially because it's not even valid in all cases anyways.

[rriddle]

In D129917#3660016, @rriddle wrote:

In D129917#3660013, @mehdi_amini wrote:

In D129917#3659550, @rriddle wrote:

In D129917#3659532, @mehdi_amini wrote:

Have you already thought of alternatives for it?

No, but this is not a strong enough justification to warrant keeping it. I don't think we should have an attribute solely for elision, so we don't have a huge number of options right now.

I don't necessarily disagree with you that we may not want to keep an attribute for this purpose (even though that's debatable). I disagree however in that the motivation to remove it is enough to degrade the elision feature in this way right now: I don't think the new behavior is OK.

Should we drop the ability to run elided IR then? What do you have in mind? I'm strongly against keeping this just for elision, especially because it's not even valid in all cases anyways.

The only way I really see keeping this behavior (without using splat) is by using https://reviews.llvm.org/D130022 (builtin ElementsAttr backed by resources). That still has the problem though that the IR isn't guaranteed to be valid if an op actually expects DenseElementsAttr/SparseElementsAttr/etc.

[rriddle]

Updated to use the new resource attr for elision.

mlir/include/mlir-c/BuiltinAttributes.h

 MLIR_CAPI_EXPORTED MlirStringRef
 mlirDenseElementsAttrGetStringValue(MlirAttribute attr, intptr_t pos);
 
 /// Returns the raw data of the given dense elements attribute.
 MLIR_CAPI_EXPORTED const void *
 mlirDenseElementsAttrGetRawData(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
-// Opaque elements attribute.
-//===----------------------------------------------------------------------===//
-
-// TODO: expose Dialect to the bindings and implement accessors here.
-
-/// Checks whether the given attribute is an opaque elements attribute.
-MLIR_CAPI_EXPORTED bool mlirAttributeIsAOpaqueElements(MlirAttribute attr);
-
-//===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a sparse elements attribute.
 MLIR_CAPI_EXPORTED bool mlirAttributeIsASparseElements(MlirAttribute attr);
 
 /// Creates a sparse elements attribute of the given shape from a list of
 /// indices and a list of associated values. Both lists are expected to be dense

mlir/include/mlir/IR/BuiltinAttributes.td

AttrBuilderWithInferredContext<(ins "StringAttr":$dialect,
       return $_get(dialect.getContext(), dialect, attrData, type);
     }]>
   ];
   let genVerifyDecl = 1;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
-// OpaqueElementsAttr
-//===----------------------------------------------------------------------===//
-
-def Builtin_OpaqueElementsAttr : Builtin_Attr<
-    "OpaqueElements", [ElementsAttrInterface]
-  > {
-  let summary = "An opaque representation of a multi-dimensional array";
-  let description = [{
-    Syntax:
-
-    ```
-    opaque-elements-attribute ::= `opaque` `<` dialect-namespace  `,`
-                                  hex-string-literal `>` `:`
-                                  ( tensor-type | vector-type )
-    ```
-
-    An opaque elements attribute is an elements attribute where the content of
-    the value is opaque. The representation of the constant stored by this
-    elements attribute is only understood, and thus decodable, by the dialect
-    that created it.
-
-    Note: The parsed string literal must be in hexadecimal form.
-
-    Examples:
-
-    ```mlir
-    opaque<"foo_dialect", "0xDEADBEEF"> : tensor<10xi32>
-    ```
-  }];
-
-  // TODO: Provide a way to avoid copying content of large opaque
-  // tensors This will likely require a new reference attribute kind.
-  let parameters = (ins "StringAttr":$dialect,
-                        StringRefParameter<"">:$value,
-                        AttributeSelfTypeParameter<"", "ShapedType">:$type);
-  let builders = [
-    AttrBuilderWithInferredContext<(ins "StringAttr":$dialect,
-                                        "ShapedType":$type,
-                                        "StringRef":$value), [{
-      return $_get(dialect.getContext(), dialect, value, type);
-    }]>,
-    AttrBuilderWithInferredContext<(ins "Dialect *":$dialect,
-                                        "ShapedType":$type,
-                                        "StringRef":$value), [{
-      MLIRContext *ctxt = dialect->getContext();
-      StringAttr dialectName = StringAttr::get(ctxt, dialect->getNamespace());
-      return $_get(ctxt, dialectName, value, type);
-    }]>
-  ];
-  let extraClassDeclaration = [{
-    using ValueType = StringRef;
-
-    /// Decodes the attribute value using dialect-specific decoding hook.
-    /// Returns false if decoding is successful. If not, returns true and leaves
-    /// 'result' argument unspecified.
-    bool decode(ElementsAttr &result);
-  }];
-  let genVerifyDecl = 1;
-  let skipDefaultBuilders = 1;
-}
-
-//===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_SparseElementsAttr : Builtin_Attr<
     "SparseElements", [ElementsAttrInterface]
   > {
   let summary = "An opaque representation of a multi-dimensional array";
   let description = [{

mlir/include/mlir/Interfaces/DecodeAttributesInterfaces.h

-//===- DecodeAttributesInterfaces.h - DecodeAttributes Interfaces -*- C++ -*-=//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-#ifndef MLIR_INTERFACES_DECODEATTRIBUTESINTERFACES_H_
-#define MLIR_INTERFACES_DECODEATTRIBUTESINTERFACES_H_
-
-#include "mlir/IR/BuiltinAttributes.h"
-#include "mlir/IR/DialectInterface.h"
-#include "mlir/Support/LogicalResult.h"
-
-namespace mlir {
-
-/// Define an interface to decode opaque constant tensor.
-class DialectDecodeAttributesInterface
-    : public DialectInterface::Base<DialectDecodeAttributesInterface> {
-public:
-  DialectDecodeAttributesInterface(Dialect *dialect) : Base(dialect) {}
-
-  /// Registered hook to decode opaque constants associated with this
-  /// dialect. The hook function attempts to decode an opaque constant tensor
-  /// into a tensor with non-opaque content. If decoding is successful, this
-  /// method returns success() and sets 'output' attribute. If not, it returns
-  /// failure() and leaves 'output' unspecified. The default hook fails to
-  /// decode.
-  virtual LogicalResult decode(OpaqueElementsAttr input,
-                               ElementsAttr &output) const {
-    return failure();
-  }
-};
-
-} // namespace mlir
-
-#endif // MLIR_INTERFACES_DECODEATTRIBUTESINTERFACES_H_

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 // Raw data accessors.
 
 const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
   return static_cast<const void *>(
       unwrap(attr).cast<DenseElementsAttr>().getRawData().data());
 }
 
 //===----------------------------------------------------------------------===//
-// Opaque elements attribute.
-//===----------------------------------------------------------------------===//
-
-bool mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
-  return unwrap(attr).isa<OpaqueElementsAttr>();
-}
-
-//===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,

mlir/lib/IR/AsmPrinter.cpp

 /// represented as a string prefixed with '@'. The reference is surrounded with
 /// ""'s and escaped if it has any special or non-printable characters in it.
 static void printSymbolReference(StringRef symbolRef, raw_ostream &os) {
   assert(!symbolRef.empty() && "expected valid symbol reference");
   os << '@';
   printKeywordOrString(symbolRef, os);
 }
 
-// Print out a valid ElementsAttr that is succinct and can represent any
-// potential shape/type, for use when eliding a large ElementsAttr.
-//
-// We choose to use an opaque ElementsAttr literal with conspicuous content to
-// hopefully alert readers to the fact that this has been elided.
-//
-// Unfortunately, neither of the strings of an opaque ElementsAttr literal will
-// accept the string "elided". The first string must be a registered dialect
-// name and the latter must be a hex constant.
-static void printElidedElementsAttr(raw_ostream &os) {
-  os << R"(opaque<"elided_large_const", "0xDEADBEEF">)";
-}
-
 LogicalResult AsmPrinter::Impl::printAlias(Attribute attr) {
   return success(state && succeeded(state->getAliasState().getAlias(attr, os)));
 }
 
 LogicalResult AsmPrinter::Impl::printAlias(Type type) {
   return success(state && succeeded(state->getAliasState().getAlias(type, os)));
 }
 
void AsmPrinter::Impl::printAttribute(Attribute attr,
 
   } else if (auto refAttr = attr.dyn_cast<SymbolRefAttr>()) {
     printSymbolReference(refAttr.getRootReference().getValue(), os);
     for (FlatSymbolRefAttr nestedRef : refAttr.getNestedReferences()) {
       os << "::";
       printSymbolReference(nestedRef.getValue(), os);
     }
 
-  } else if (auto opaqueAttr = attr.dyn_cast<OpaqueElementsAttr>()) {
-    if (printerFlags.shouldElideElementsAttr(opaqueAttr)) {
-      printElidedElementsAttr(os);
-    } else {
-      os << "opaque<" << opaqueAttr.getDialect() << ", ";
-      printHexString(opaqueAttr.getValue());
-      os << ">";
-    }
-
   } else if (auto intOrFpEltAttr = attr.dyn_cast<DenseIntOrFPElementsAttr>()) {
-    if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) {
-      printElidedElementsAttr(os);
-    } else {
-      os << "dense<";
-      printDenseIntOrFPElementsAttr(intOrFpEltAttr, /*allowHex=*/true);
-      os << '>';
-    }
-
   } else if (auto strEltAttr = attr.dyn_cast<DenseStringElementsAttr>()) {
-    if (printerFlags.shouldElideElementsAttr(strEltAttr)) {
-      printElidedElementsAttr(os);
-    } else {
-      os << "dense<";
-      printDenseStringElementsAttr(strEltAttr);
-      os << '>';
-    }
-
   } else if (auto sparseEltAttr = attr.dyn_cast<SparseElementsAttr>()) {
-    if (printerFlags.shouldElideElementsAttr(sparseEltAttr.getIndices()) ||
-        printerFlags.shouldElideElementsAttr(sparseEltAttr.getValues())) {
-      printElidedElementsAttr(os);
-    } else {
-      os << "sparse<";
-      DenseIntElementsAttr indices = sparseEltAttr.getIndices();
-      if (indices.getNumElements() != 0) {
-        printDenseIntOrFPElementsAttr(indices, /*allowHex=*/false);
-        os << ", ";
-        printDenseElementsAttr(sparseEltAttr.getValues(), /*allowHex=*/true);
-      }
-      os << '>';
-    }
   } else if (auto denseArrayAttr = attr.dyn_cast<DenseArrayBaseAttr>()) {
     typeElision = AttrTypeElision::Must;
     switch (denseArrayAttr.getElementType()) {
     case DenseArrayBaseAttr::EltType::I8:
       os << "[:i8";
       break;
     case DenseArrayBaseAttr::EltType::I16:
       os << "[:i16";
if (value.getBitWidth() == 1)
     os << (value.getBoolValue() ? "true" : "false");
   else
     value.print(os, isSigned);
 }
 
 static void
 printDenseElementsAttrImpl(bool isSplat, ShapedType type, raw_ostream &os,
                            function_ref<void(unsigned)> printEltFn) {
-  // Special case for 0-d and splat tensors.
-  if (isSplat)
-    return printEltFn(0);
-
   // Special case for degenerate tensors.
-  auto numElements = type.getNumElements();
+  int64_t numElements = type.getNumElements();
   if (numElements == 0)
     return;
 
+  // Special case for 0-d and splat tensors.
+  if (isSplat)
+    return printEltFn(0);
+
   // 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'.
   int64_t rank = type.getRank();
   SmallVector<unsigned, 4> counter(rank, 0);
   // The number of brackets that have been opened and not closed.
void AsmPrinter::Impl::printDenseElementsAttr(DenseElementsAttr attr,
   printDenseIntOrFPElementsAttr(attr.cast<DenseIntOrFPElementsAttr>(),
                                 allowHex);
 }
 
 void AsmPrinter::Impl::printDenseIntOrFPElementsAttr(
     DenseIntOrFPElementsAttr attr, bool allowHex) {
   auto type = attr.getType();
   auto elementType = type.getElementType();
+  bool printAsSplat =
+      attr.isSplat() || printerFlags.shouldElideElementsAttr(attr);
 
   // Check to see if we should format this attribute as a hex string.
   auto numElements = type.getNumElements();
-  if (!attr.isSplat() && allowHex &&
+  if (!printAsSplat && allowHex &&
       shouldPrintElementsAttrWithHex(numElements)) {
     ArrayRef<char> rawData = attr.getRawData();
     if (llvm::support::endian::system_endianness() ==
         llvm::support::endianness::big) {
       // Convert endianess in big-endian(BE) machines. `rawData` is BE in BE
       // machines. It is converted here to print in LE format.
       SmallVector<char, 64> outDataVec(rawData.size());
       MutableArrayRef<char> convRawData(outDataVec);
void AsmPrinter::Impl::printDenseIntOrFPElementsAttr(
   if (ComplexType complexTy = elementType.dyn_cast<ComplexType>()) {
     Type complexElementType = complexTy.getElementType();
     // Note: The if and else below had a common lambda function which invoked
     // 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) {
+      printDenseElementsAttrImpl(printAsSplat, type, os, [&](unsigned index) {
         auto complexValue = *(valueIt + index);
         os << "(";
         printDenseIntElement(complexValue.real(), os, isSigned);
         os << ",";
         printDenseIntElement(complexValue.imag(), os, isSigned);
         os << ")";
       });
     } else {
       auto valueIt = attr.value_begin<std::complex<APFloat>>();
-      printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
+      printDenseElementsAttrImpl(printAsSplat, type, os, [&](unsigned index) {
         auto complexValue = *(valueIt + index);
         os << "(";
         printFloatValue(complexValue.real(), os);
         os << ",";
         printFloatValue(complexValue.imag(), os);
         os << ")";
       });
     }
   } else if (elementType.isIntOrIndex()) {
     bool isSigned = !elementType.isUnsignedInteger();
     auto valueIt = attr.value_begin<APInt>();
-    printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
+    printDenseElementsAttrImpl(printAsSplat, type, os, [&](unsigned index) {
       printDenseIntElement(*(valueIt + index), os, isSigned);
     });
   } else {
     assert(elementType.isa<FloatType>() && "unexpected element type");
     auto valueIt = attr.value_begin<APFloat>();
-    printDenseElementsAttrImpl(attr.isSplat(), type, os, [&](unsigned index) {
+    printDenseElementsAttrImpl(printAsSplat, type, os, [&](unsigned index) {
       printFloatValue(*(valueIt + index), os);
     });
   }
 }
 
 void AsmPrinter::Impl::printDenseStringElementsAttr(
     DenseStringElementsAttr attr) {
+  bool printAsSplat =
+      attr.isSplat() || printerFlags.shouldElideElementsAttr(attr);
   ArrayRef<StringRef> data = attr.getRawStringData();
   auto printFn = [&](unsigned index) { printEscapedString(data[index]); };
-  printDenseElementsAttrImpl(attr.isSplat(), attr.getType(), os, printFn);
+  printDenseElementsAttrImpl(printAsSplat, attr.getType(), os, printFn);
 }
 
 void AsmPrinter::Impl::printType(Type type) {
   if (!type) {
     os << "<<NULL TYPE>>";
     return;
   }
 

mlir/lib/IR/BuiltinAttributes.cpp

 #include "mlir/IR/AffineMap.h"
 #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"
-#include "mlir/Interfaces/DecodeAttributesInterfaces.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/Support/Endian.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 //===----------------------------------------------------------------------===//
 /// Tablegen Attribute Definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/IR/BuiltinAttributes.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // BuiltinDialect
 //===----------------------------------------------------------------------===//
 
 void BuiltinDialect::registerAttributes() {
   addAttributes<AffineMapAttr, ArrayAttr, DenseArrayBaseAttr,
                 DenseIntOrFPElementsAttr, DenseStringElementsAttr,
                 DictionaryAttr, FloatAttr, SymbolRefAttr, IntegerAttr,
-                IntegerSetAttr, OpaqueAttr, OpaqueElementsAttr,
-                SparseElementsAttr, StringAttr, TypeAttr, UnitAttr>();
+                IntegerSetAttr, OpaqueAttr, SparseElementsAttr, StringAttr,
+                TypeAttr, UnitAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAttr
 //===----------------------------------------------------------------------===//
 
 void ArrayAttr::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,

 
 /// Method for supporting type inquiry through isa, cast and dyn_cast.
 bool DenseIntElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseElementsAttr>() &&
          attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
 }
 
 //===----------------------------------------------------------------------===//
-// OpaqueElementsAttr
-//===----------------------------------------------------------------------===//
-
-bool OpaqueElementsAttr::decode(ElementsAttr &result) {
-  Dialect *dialect = getContext()->getLoadedDialect(getDialect());
-  if (!dialect)
-    return true;
-  auto *interface = llvm::dyn_cast<DialectDecodeAttributesInterface>(dialect);
-  if (!interface)
-    return true;
-  return failed(interface->decode(*this, result));
-}
-
-LogicalResult
-OpaqueElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
-                           StringAttr dialect, StringRef value,
-                           ShapedType type) {
-  if (!Dialect::isValidNamespace(dialect.strref()))
-    return emitError() << "invalid dialect namespace '" << dialect << "'";
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Get a zero APFloat for the given sparse attribute.
 APFloat SparseElementsAttr::getZeroAPFloat() const {
   auto eltType = getElementType().cast<FloatType>();
   return APFloat(eltType.getFloatSemantics());
 }

mlir/lib/Parser/AttributeParser.cpp

case Token::kw_loc: {
     LocationAttr locAttr;
     if (parseToken(Token::l_paren, "expected '(' in inline location") ||
         parseLocationInstance(locAttr) ||
         parseToken(Token::r_paren, "expected ')' in inline location"))
       return Attribute();
     return locAttr;
   }
 
-  // Parse an opaque elements attribute.
-  case Token::kw_opaque:
-    return parseOpaqueElementsAttr(type);
-
   // Parse a sparse elements attribute.
   case Token::kw_sparse:
     return parseSparseElementsAttr(type);
 
   // Parse a string attribute.
   case Token::string: {
     auto val = getToken().getStringValue();
     consumeToken(Token::string);
OptionalParseResult Parser::parseOptionalAttribute(Attribute &attribute,
   case Token::floatliteral:
   case Token::integer:
   case Token::hash_identifier:
   case Token::kw_affine_map:
   case Token::kw_affine_set:
   case Token::kw_dense:
   case Token::kw_false:
   case Token::kw_loc:
-  case Token::kw_opaque:
   case Token::kw_sparse:
   case Token::kw_true:
   case Token::kw_unit:
   case Token::l_brace:
   case Token::l_square:
   case Token::minus:
   case Token::string:
     attribute = parseAttribute(type);
Attribute Parser::parseDenseElementsAttr(Type attrType) {
   // case.
   auto loc = attrType ? attribLoc : getToken().getLoc();
   auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
   return literalParser.getAttr(loc, type);
 }
 
-/// Parse an opaque elements attribute.
-Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
-  SMLoc loc = getToken().getLoc();
-  consumeToken(Token::kw_opaque);
-  if (parseToken(Token::less, "expected '<' after 'opaque'"))
-    return nullptr;
-
-  if (getToken().isNot(Token::string))
-    return (emitError("expected dialect namespace"), nullptr);
-
-  std::string name = getToken().getStringValue();
-  consumeToken(Token::string);
-
-  if (parseToken(Token::comma, "expected ','"))
-    return nullptr;
-
-  Token hexTok = getToken();
-  if (parseToken(Token::string, "elements hex string should start with '0x'") ||
-      parseToken(Token::greater, "expected '>'"))
-    return nullptr;
-  auto type = parseElementsLiteralType(attrType);
-  if (!type)
-    return nullptr;
-
-  std::string data;
-  if (parseElementAttrHexValues(*this, hexTok, data))
-    return nullptr;
-  return getChecked<OpaqueElementsAttr>(loc, builder.getStringAttr(name), type,
-                                        data);
-}
-
 /// Shaped type for elements attribute.
 ///
 ///   elements-literal-type ::= vector-type | ranked-tensor-type
 ///
 /// This method also checks the type has static shape.
 ShapedType Parser::parseElementsLiteralType(Type type) {
   // If the user didn't provide a type, parse the colon type for the literal.
   if (!type) {

mlir/lib/Parser/Parser.h

public:
 
   /// Parse a float attribute.
   Attribute parseFloatAttr(Type type, bool isNegative);
 
   /// Parse a decimal or a hexadecimal literal, which can be either an integer
   /// or a float attribute.
   Attribute parseDecOrHexAttr(Type type, bool isNegative);
 
-  /// Parse an opaque elements attribute.
-  Attribute parseOpaqueElementsAttr(Type attrType);
-
   /// Parse a dense elements attribute.
   Attribute parseDenseElementsAttr(Type attrType);
   ShapedType parseElementsLiteralType(Type type);
 
   /// Parse a DenseArrayAttr.
   Attribute parseDenseArrayAttr();
 
   /// Parse a sparse elements attribute.

mlir/lib/Parser/TokenKinds.def

 TOK_KEYWORD(index)
 TOK_KEYWORD(loc)
 TOK_KEYWORD(max)
 TOK_KEYWORD(memref)
 TOK_KEYWORD(min)
 TOK_KEYWORD(mod)
 TOK_KEYWORD(none)
 TOK_KEYWORD(offset)
-TOK_KEYWORD(opaque)
 TOK_KEYWORD(size)
 TOK_KEYWORD(sparse)
 TOK_KEYWORD(step)
 TOK_KEYWORD(strides)
 TOK_KEYWORD(symbol)
 TOK_KEYWORD(tensor)
 TOK_KEYWORD(to)
 TOK_KEYWORD(true)

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

for (StringRef token : tokens) {
       item.detail = optional ? "optional" : "";
       completionList.items.emplace_back(item);
     }
   }
 
   /// Signal a completion for an attribute.
   void completeAttribute(const llvm::StringMap<Attribute> &aliases) override {
     appendSimpleCompletions({"affine_set", "affine_map", "dense", "false",
-                             "loc", "opaque", "sparse", "true", "unit"},
+                             "loc", "sparse", "true", "unit"},
                             lsp::CompletionItemKind::Field,
                             /*sortText=*/"1");
 
     completeDialectName("#");
     completeAliases(aliases, "#");
   }
   void completeDialectAttributeOrAlias(
       const llvm::StringMap<Attribute> &aliases) override {

mlir/test/CAPI/ir.c

static void printFirstOfEach(MlirContext ctx, MlirOperation operation) {
   mlirOpPrintingFlagsElideLargeElementsAttrs(flags, 2);
   mlirOpPrintingFlagsPrintGenericOpForm(flags);
   mlirOpPrintingFlagsEnableDebugInfo(flags, /*prettyForm=*/0);
   mlirOpPrintingFlagsUseLocalScope(flags);
   fprintf(stderr, "Op print with all flags: ");
   mlirOperationPrintWithFlags(operation, flags, printToStderr, NULL);
   fprintf(stderr, "\n");
   // clang-format off
-  // CHECK: Op print with all flags: %{{.*}} = "arith.constant"() {elts = opaque<"elided_large_const", "0xDEADBEEF"> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
+  // CHECK: Op print with all flags: %{{.*}} = "arith.constant"() {elts = dense<1> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown)
   // clang-format on
 
   mlirOpPrintingFlagsDestroy(flags);
 }
 
 static int constructAndTraverseIr(MlirContext ctx) {
   MlirLocation location = mlirLocationUnknownGet(ctx);
 

mlir/test/IR/attribute.mlir

 func.func @wrong_shape_fail() {
   // expected-error @+1 {{failed to satisfy constraint: 32-bit signless int elements attribute of shape [2]}}
   "test.ranked_int_elements_attr"() {
     matrix_i64_attr = dense<6> : tensor<4x8xi64>,
     vector_i32_attr = dense<5> : tensor<i32>
   } : () -> ()
   return
 }
-
-// -----
-
-// expected-error @+1 {{invalid dialect namespace '"string with space"'}}
-#invalid_dialect = opaque<"string with space", "0xDEADBEEF"> : tensor<100xi32>
-

mlir/test/IR/elements-attr-interface.mlir

 arith.constant #test.i64_elements<[10, 11, 12, 13, 14]> : tensor<5xi64>
 
 // expected-error@below {{Test iterating `int64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `uint64_t`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `APInt`: 10, 11, 12, 13, 14}}
 // expected-error@below {{Test iterating `IntegerAttr`: 10 : i64, 11 : i64, 12 : i64, 13 : i64, 14 : i64}}
 arith.constant dense<[10, 11, 12, 13, 14]> : tensor<5xi64>
 
-// expected-error@below {{Test iterating `int64_t`: unable to iterate type}}
-// expected-error@below {{Test iterating `uint64_t`: unable to iterate type}}
-// expected-error@below {{Test iterating `APInt`: unable to iterate type}}
-// expected-error@below {{Test iterating `IntegerAttr`: unable to iterate type}}
-arith.constant opaque<"_", "0xDEADBEEF"> : tensor<5xi64>
-
 // Check that we don't crash on empty element attributes.
 // expected-error@below {{Test iterating `int64_t`: }}
 // expected-error@below {{Test iterating `uint64_t`: }}
 // expected-error@below {{Test iterating `APInt`: }}
 // expected-error@below {{Test iterating `IntegerAttr`: }}
 arith.constant dense<> : tensor<0xi64>
 
 // expected-error@below {{Test iterating `int8_t`: 10, 11, -12, 13, 14}}

mlir/test/IR/invalid.mlir

 "foo"(){bar = dense<[(10,)]> : tensor<complex<i64>>} : () -> () // expected-error {{expected element literal of primitive type}}
 
 // -----
 
 "foo"(){bar = dense<[(10,10]> : tensor<complex<i64>>} : () -> () // expected-error {{expected ')' after complex elements}}
 
 // -----
 
-func.func @elementsattr_malformed_opaque() -> () {
-^bb0:
-  "foo"(){bar = opaque<10, "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected dialect namespace}}
-}
-
-// -----
-
-func.func @elementsattr_malformed_opaque1() -> () {
-^bb0:
-  "foo"(){bar = opaque<"_", "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
-}
-
-// -----
-
-func.func @elementsattr_malformed_opaque2() -> () {
-^bb0:
-  "foo"(){bar = opaque<"_", "00abc"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}}
-}
-
-// -----
-
 func.func @redundant_signature(%a : i32) -> () {
 ^bb0(%b : i32):  // expected-error {{invalid block name in region with named arguments}}
   return
 }
 
 // -----
 
 func.func @mixed_named_arguments(%a : i32,

 
 // -----
 
 !redef_alias = i32
 !redef_alias = i32 // expected-error {{redefinition of type alias id 'redef_alias'}}
 
 // -----
 
-// Check ill-formed opaque tensor.
-func.func @complex_loops() {
-  affine.for %i1 = 1 to 100 {
-  // expected-error @+1 {{expected '"' in string literal}}
-  "opaqueIntTensor"(){bar = opaque<"_", "0x686]> : tensor<2x1x4xi32>} : () -> ()
-
-// -----
-
 func.func @mi() {
   // expected-error @+1 {{expected element literal of primitive type}}
   "fooi64"(){bar = sparse<vector<1xi64>,[,[,1]
 
 // -----
 
 func.func @invalid_tensor_literal() {
   // expected-error @+1 {{expected 1-d tensor for sparse element values}}

mlir/test/IR/pretty-attributes.mlir

 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | FileCheck %s
 // Ensure that the elided version is still parseable, although depending on
 // what has been elided, it may not be semantically meaningful.
 // In the typical case where what is being elided is a very large constant
 // tensor which passes don't look at directly, this isn't an issue.
 // RUN: mlir-opt %s -mlir-elide-elementsattrs-if-larger=2 | mlir-opt
 
-// CHECK: opaque<"elided_large_const", "0xDEADBEEF"> : tensor<3xi32>
+// CHECK: dense<1> : tensor<3xi32>
 "test.dense_attr"() {foo.dense_attr = dense<[1, 2, 3]> : tensor<3xi32>} : () -> ()
 
 // CHECK: dense<[1, 2]> : tensor<2xi32>
 "test.non_elided_dense_attr"() {foo.dense_attr = dense<[1, 2]> : tensor<2xi32>} : () -> ()
 
-// CHECK: opaque<"elided_large_const", "0xDEADBEEF"> : vector<1x1x10xf16>
+// CHECK: sparse<0, -2.000000e+00> : vector<1x1x10xf16>
 "test.sparse_attr"() {foo.sparse_attr = sparse<[[0, 0, 5]],  -2.0> : vector<1x1x10xf16>} : () -> ()
 
-// CHECK: opaque<"elided_large_const", "0xDEADBEEF"> : tensor<100xf32>
-"test.opaque_attr"() {foo.opaque_attr = opaque<"elided_large_const", "0xEBFE"> : tensor<100xf32> } : () -> ()
-
 // CHECK: dense<1> : tensor<3xi32>
 "test.dense_splat"() {foo.dense_attr = dense<1> : tensor<3xi32>} : () -> ()

mlir/test/python/ir/operation.py

def testOperationPrint():
   print(bytes_value.__class__)
   print(bytes_value)
 
   # Test get_asm local_scope.
   # CHECK: constant dense<[1, 2, 3, 4]> : tensor<4xi32> loc("nom")
   module.operation.print(enable_debug_info=True, use_local_scope=True)
 
   # Test get_asm with options.
-  # CHECK: value = opaque<"elided_large_const", "0xDEADBEEF"> : tensor<4xi32>
+  # CHECK: value = dense<1> : tensor<4xi32>
   # CHECK: "func.return"(%arg0) : (i32) -> () -:4:7
   module.operation.print(
       large_elements_limit=2,
       enable_debug_info=True,
       pretty_debug_info=True,
       print_generic_op_form=True,
       use_local_scope=True)
 

mlir/utils/gdb-scripts/prettyprinters.py

for name in [
     'IntegerSetAttr',
     'OpaqueAttr',
     'StringAttr',
     'SymbolRefAttr',
     'TypeAttr',
     'UnitAttr',
     'DenseStringElementsAttr',
     'DenseIntOrFPElementsAttr',
-    'OpaqueElementsAttr',
     'SparseElementsAttr',
     # mlir/IR/BuiltinTypes.h
     'ComplexType',
     'IndexType',
     'IntegerType',
     'Float16Type',
     'Float32Type',
     'Float64Type',