1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
// RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=ATTR
// RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=TYPE
include "mlir/IR/AttrTypeBase.td"
include "mlir/IR/OpBase.td"
/// Test that attribute and type printers and parsers are correctly generated.
def Test_Dialect : Dialect {
let name = "TestDialect";
let cppNamespace = "::test";
let useDefaultAttributePrinterParser = 1;
let useDefaultTypePrinterParser = 1;
}
class TestAttr<string name> : AttrDef<Test_Dialect, name>;
class TestType<string name> : TypeDef<Test_Dialect, name>;
def AttrA : TestAttr<"AttrA"> {
let mnemonic = "attr_a";
}
// ATTR: namespace test {
// ATTR: ::mlir::Attribute TestDialect::parseAttribute(::mlir::DialectAsmParser &parser,
// ATTR: ::mlir::Type type) const {
// ATTR: ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
// ATTR: ::llvm::StringRef attrTag;
// ATTR: {
// ATTR: ::mlir::Attribute attr;
// ATTR: auto parseResult = generatedAttributeParser(parser, &attrTag, type, attr);
// ATTR: if (parseResult.has_value())
// ATTR: return attr;
// ATTR: }
// ATTR: parser.emitError(typeLoc) << "unknown attribute `"
// ATTR: << attrTag << "` in dialect `" << getNamespace() << "`";
// ATTR: return {}
// ATTR: }
// ATTR: void TestDialect::printAttribute(::mlir::Attribute attr,
// ATTR: ::mlir::DialectAsmPrinter &printer) const {
// ATTR: if (::mlir::succeeded(generatedAttributePrinter(attr, printer)))
// ATTR: return;
// ATTR: }
// ATTR: } // namespace test
def TypeA : TestType<"TypeA"> {
let mnemonic = "type_a";
}
// TYPE: namespace test {
// TYPE: ::mlir::Type TestDialect::parseType(::mlir::DialectAsmParser &parser) const {
// TYPE: ::llvm::SMLoc typeLoc = parser.getCurrentLocation();
// TYPE: ::llvm::StringRef mnemonic;
// TYPE: ::mlir::Type genType;
// TYPE: auto parseResult = generatedTypeParser(parser, &mnemonic, genType);
// TYPE: if (parseResult.has_value())
// TYPE: return genType;
// TYPE: parser.emitError(typeLoc) << "unknown type `"
// TYPE: << mnemonic << "` in dialect `" << getNamespace() << "`";
// TYPE: return {};
// TYPE: }
// TYPE: void TestDialect::printType(::mlir::Type type,
// TYPE: ::mlir::DialectAsmPrinter &printer) const {
// TYPE: if (::mlir::succeeded(generatedTypePrinter(type, printer)))
// TYPE: return;
// TYPE: }
// TYPE: } // namespace test
|
