diff --git a/mlir/include/mlir-c/BuiltinAttributes.h b/mlir/include/mlir-c/BuiltinAttributes.h --- a/mlir/include/mlir-c/BuiltinAttributes.h +++ b/mlir/include/mlir-c/BuiltinAttributes.h @@ -455,15 +455,6 @@ 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. //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/IR/BuiltinAttributes.td b/mlir/include/mlir/IR/BuiltinAttributes.td --- a/mlir/include/mlir/IR/BuiltinAttributes.td +++ b/mlir/include/mlir/IR/BuiltinAttributes.td @@ -801,68 +801,6 @@ let skipDefaultBuilders = 1; } -//===----------------------------------------------------------------------===// -// OpaqueElementsAttr -//===----------------------------------------------------------------------===// - -def Builtin_OpaqueElementsAttr : Builtin_Attr< - "OpaqueElements", [ElementsAttrInterface, TypedAttrInterface] - > { - 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 //===----------------------------------------------------------------------===// diff --git a/mlir/include/mlir/Interfaces/DecodeAttributesInterfaces.h b/mlir/include/mlir/Interfaces/DecodeAttributesInterfaces.h deleted file mode 100644 --- a/mlir/include/mlir/Interfaces/DecodeAttributesInterfaces.h +++ /dev/null @@ -1,37 +0,0 @@ -//===- 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 { -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_ diff --git a/mlir/lib/AsmParser/AttributeParser.cpp b/mlir/lib/AsmParser/AttributeParser.cpp --- a/mlir/lib/AsmParser/AttributeParser.cpp +++ b/mlir/lib/AsmParser/AttributeParser.cpp @@ -42,8 +42,6 @@ /// (tensor-type | vector-type) /// | `sparse` `<` attribute-value `,` attribute-value `>` /// `:` (tensor-type | vector-type) -/// | `opaque` `<` dialect-namespace `,` hex-string-literal -/// `>` `:` (tensor-type | vector-type) /// | extended-attribute /// Attribute Parser::parseAttribute(Type type) { @@ -143,10 +141,6 @@ 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); @@ -249,7 +243,6 @@ case Token::kw_dense_resource: case Token::kw_false: case Token::kw_loc: - case Token::kw_opaque: case Token::kw_sparse: case Token::kw_true: case Token::kw_unit: @@ -967,37 +960,6 @@ return DenseResourceElementsAttr::get(shapedType, *handle); } -/// 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(loc, builder.getStringAttr(name), type, - data); -} - /// Shaped type for elements attribute. /// /// elements-literal-type ::= vector-type | ranked-tensor-type diff --git a/mlir/lib/AsmParser/Parser.h b/mlir/lib/AsmParser/Parser.h --- a/mlir/lib/AsmParser/Parser.h +++ b/mlir/lib/AsmParser/Parser.h @@ -266,9 +266,6 @@ /// 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); diff --git a/mlir/lib/AsmParser/TokenKinds.def b/mlir/lib/AsmParser/TokenKinds.def --- a/mlir/lib/AsmParser/TokenKinds.def +++ b/mlir/lib/AsmParser/TokenKinds.def @@ -105,7 +105,6 @@ TOK_KEYWORD(mod) TOK_KEYWORD(none) TOK_KEYWORD(offset) -TOK_KEYWORD(opaque) TOK_KEYWORD(size) TOK_KEYWORD(sparse) TOK_KEYWORD(step) diff --git a/mlir/lib/CAPI/IR/BuiltinAttributes.cpp b/mlir/lib/CAPI/IR/BuiltinAttributes.cpp --- a/mlir/lib/CAPI/IR/BuiltinAttributes.cpp +++ b/mlir/lib/CAPI/IR/BuiltinAttributes.cpp @@ -598,14 +598,6 @@ unwrap(attr).cast().getRawData().data()); } -//===----------------------------------------------------------------------===// -// Opaque elements attribute. -//===----------------------------------------------------------------------===// - -bool mlirAttributeIsAOpaqueElements(MlirAttribute attr) { - return unwrap(attr).isa(); -} - //===----------------------------------------------------------------------===// // Sparse elements attribute. //===----------------------------------------------------------------------===// diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp --- a/mlir/lib/IR/AsmPrinter.cpp +++ b/mlir/lib/IR/AsmPrinter.cpp @@ -1724,14 +1724,10 @@ // 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. +// We choose to use a dense resource ElementsAttr literal with conspicuous +// content to hopefully alert readers to the fact that this has been elided. static void printElidedElementsAttr(raw_ostream &os) { - os << R"(opaque<"elided_large_const", "0xDEADBEEF">)"; + os << R"(dense_resource<__elided__>)"; } LogicalResult AsmPrinter::Impl::printAlias(Attribute attr) { @@ -1830,15 +1826,6 @@ printSymbolReference(nestedRef.getValue(), os); } - } else if (auto opaqueAttr = attr.dyn_cast()) { - if (printerFlags.shouldElideElementsAttr(opaqueAttr)) { - printElidedElementsAttr(os); - } else { - os << "opaque<" << opaqueAttr.getDialect() << ", "; - printHexString(opaqueAttr.getValue()); - os << ">"; - } - } else if (auto intOrFpEltAttr = attr.dyn_cast()) { if (printerFlags.shouldElideElementsAttr(intOrFpEltAttr)) { printElidedElementsAttr(os); diff --git a/mlir/lib/IR/BuiltinAttributes.cpp b/mlir/lib/IR/BuiltinAttributes.cpp --- a/mlir/lib/IR/BuiltinAttributes.cpp +++ b/mlir/lib/IR/BuiltinAttributes.cpp @@ -17,7 +17,6 @@ #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" @@ -1700,29 +1699,6 @@ } // namespace detail } // namespace mlir -//===----------------------------------------------------------------------===// -// OpaqueElementsAttr -//===----------------------------------------------------------------------===// - -bool OpaqueElementsAttr::decode(ElementsAttr &result) { - Dialect *dialect = getContext()->getLoadedDialect(getDialect()); - if (!dialect) - return true; - auto *interface = llvm::dyn_cast(dialect); - if (!interface) - return true; - return failed(interface->decode(*this, result)); -} - -LogicalResult -OpaqueElementsAttr::verify(function_ref emitError, - StringAttr dialect, StringRef value, - ShapedType type) { - if (!Dialect::isValidNamespace(dialect.strref())) - return emitError() << "invalid dialect namespace '" << dialect << "'"; - return success(); -} - //===----------------------------------------------------------------------===// // SparseElementsAttr //===----------------------------------------------------------------------===// diff --git a/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp b/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp --- a/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp +++ b/mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp @@ -713,8 +713,8 @@ /// Signal a completion for an attribute. void completeAttribute(const llvm::StringMap &aliases) override { appendSimpleCompletions({"affine_set", "affine_map", "dense", - "dense_resource", "false", "loc", "opaque", - "sparse", "true", "unit"}, + "dense_resource", "false", "loc", "sparse", "true", + "unit"}, lsp::CompletionItemKind::Field, /*sortText=*/"1"); diff --git a/mlir/test/CAPI/ir.c b/mlir/test/CAPI/ir.c --- a/mlir/test/CAPI/ir.c +++ b/mlir/test/CAPI/ir.c @@ -473,7 +473,7 @@ 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_resource<__elided__> : tensor<4xi32>, value = 0 : index} : () -> index loc(unknown) // clang-format on mlirOpPrintingFlagsDestroy(flags); diff --git a/mlir/test/IR/attribute.mlir b/mlir/test/IR/attribute.mlir --- a/mlir/test/IR/attribute.mlir +++ b/mlir/test/IR/attribute.mlir @@ -691,9 +691,3 @@ } : () -> () return } - -// ----- - -// expected-error @+1 {{invalid dialect namespace '"string with space"'}} -#invalid_dialect = opaque<"string with space", "0xDEADBEEF"> : tensor<100xi32> - diff --git a/mlir/test/IR/elements-attr-interface.mlir b/mlir/test/IR/elements-attr-interface.mlir --- a/mlir/test/IR/elements-attr-interface.mlir +++ b/mlir/test/IR/elements-attr-interface.mlir @@ -20,12 +20,6 @@ // 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`: }} diff --git a/mlir/test/IR/invalid-builtin-attributes.mlir b/mlir/test/IR/invalid-builtin-attributes.mlir --- a/mlir/test/IR/invalid-builtin-attributes.mlir +++ b/mlir/test/IR/invalid-builtin-attributes.mlir @@ -84,24 +84,6 @@ // ----- -func.func @elementsattr_malformed_opaque() -> () { - "foo"(){bar = opaque<10, "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected dialect namespace}} -} - -// ----- - -func.func @elementsattr_malformed_opaque1() -> () { - "foo"(){bar = opaque<"_", "0xQZz123"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}} -} - -// ----- - -func.func @elementsattr_malformed_opaque2() -> () { - "foo"(){bar = opaque<"_", "00abc"> : tensor<1xi8>} : () -> () // expected-error {{expected string containing hex digits starting with `0x`}} -} - -// ----- - func.func @mi() { // expected-error @+1 {{expected element literal of primitive type}} "fooi64"(){bar = sparse,[,[,1] diff --git a/mlir/test/IR/pretty-attributes.mlir b/mlir/test/IR/pretty-attributes.mlir --- a/mlir/test/IR/pretty-attributes.mlir +++ b/mlir/test/IR/pretty-attributes.mlir @@ -5,17 +5,14 @@ // 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_resource<__elided__> : 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: dense_resource<__elided__> : 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>} : () -> () diff --git a/mlir/test/python/ir/operation.py b/mlir/test/python/ir/operation.py --- a/mlir/test/python/ir/operation.py +++ b/mlir/test/python/ir/operation.py @@ -580,7 +580,7 @@ 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_resource<__elided__> : tensor<4xi32> # CHECK: "func.return"(%arg0) : (i32) -> () -:4:7 module.operation.print( large_elements_limit=2, diff --git a/mlir/utils/gdb-scripts/prettyprinters.py b/mlir/utils/gdb-scripts/prettyprinters.py --- a/mlir/utils/gdb-scripts/prettyprinters.py +++ b/mlir/utils/gdb-scripts/prettyprinters.py @@ -161,7 +161,6 @@ 'UnitAttr', 'DenseStringElementsAttr', 'DenseIntOrFPElementsAttr', - 'OpaqueElementsAttr', 'SparseElementsAttr', # mlir/IR/BuiltinTypes.h 'ComplexType',