Debian Codegraph @

mlir/test/tblgen-to-irdl/TestDialect.td

raw
1 // RUN: tblgen-to-irdl %s -I=%S/../../include --gen-dialect-irdl-defs --dialect=test | FileCheck %s
2
3 include "mlir/IR/OpBase.td"
4 include "mlir/IR/AttrTypeBase.td"
5
6 // CHECK-LABEL: irdl.dialect @test {
7 def Test_Dialect : Dialect {
8 let name = "test";
9 }
10
11 class Test_Type<string name, string typeMnemonic, list<Trait> traits = []>
12 : TypeDef<Test_Dialect, name, traits> {
13 let mnemonic = typeMnemonic;
14 }
15
16 class Test_Attr<string name, string attrMnemonic> : AttrDef<Test_Dialect, name> {
17 let mnemonic = attrMnemonic;
18 }
19
20 class Test_Op<string mnemonic, list<Trait> traits = []>
21 : Op<Test_Dialect, mnemonic, traits>;
22
23 // CHECK: irdl.type @"!singleton_a"
24 def Test_SingletonAType : Test_Type<"SingletonAType", "singleton_a"> {}
25 // CHECK: irdl.type @"!singleton_b"
26 def Test_SingletonBType : Test_Type<"SingletonBType", "singleton_b"> {}
27 // CHECK: irdl.type @"!singleton_c"
28 def Test_SingletonCType : Test_Type<"SingletonCType", "singleton_c"> {}
29 // CHECK: irdl.attribute @"#test"
30 def Test_TestAttr : Test_Attr<"Test", "test"> {}
31
32
33 // Check that AllOfType is converted correctly.
34 def Test_AndOp : Test_Op<"and"> {
35 let arguments = (ins AllOfType<[Test_SingletonAType, AnyType]>:$in);
36 }
37 // CHECK-LABEL: irdl.operation @and {
38 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.base @test::@"!singleton_a"
39 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.any
40 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.all_of(%[[v0]], %[[v1]])
41 // CHECK-NEXT: irdl.operands(in: %[[v2]])
42 // CHECK-NEXT: }
43
44
45 // Check that AnyType is converted correctly.
46 def Test_AnyOp : Test_Op<"any"> {
47 let arguments = (ins AnyType:$in);
48 }
49 // CHECK-LABEL: irdl.operation @any {
50 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.any
51 // CHECK-NEXT: irdl.operands(in: %[[v0]])
52 // CHECK-NEXT: }
53
54 // Check attributes are converted correctly.
55 def Test_AttributesOp : Test_Op<"attributes"> {
56 let arguments = (ins I16Attr:$int_attr,
57 Test_TestAttr:$test_attr);
58 }
59 // CHECK-LABEL: irdl.operation @attributes {
60 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.base "!builtin.integer"
61 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.base @test::@"#test"
62 // CHECK-NEXT: irdl.attributes {"int_attr" = %[[v0]], "test_attr" = %[[v1]]}
63 // CHECK-NEXT: }
64
65 // Check confined types are converted correctly.
66 def Test_ConfinedOp : Test_Op<"confined"> {
67 let arguments = (ins ConfinedType<AnyType, [CPred<"::llvm::isa<::mlir::TensorType>($_self)">]>:$tensor,
68 ConfinedType<AnyType, [And<[CPred<"::llvm::isa<::mlir::VectorType>($_self)">
69 , CPred<"::llvm::cast<::mlir::VectorType>($_self).getRank() > 0">]>]>:$vector);
70 }
71 // CHECK-LABEL: irdl.operation @confined {
72 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.any
73 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.c_pred "(::llvm::isa<::mlir::TensorType>($_self))"
74 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.all_of(%[[v0]], %[[v1]])
75 // CHECK-NEXT: %[[v3:[^ ]*]] = irdl.any
76 // CHECK-NEXT: %[[v4:[^ ]*]] = irdl.c_pred "(::llvm::isa<::mlir::VectorType>($_self))"
77 // CHECK-NEXT: %[[v5:[^ ]*]] = irdl.c_pred "(::llvm::cast<::mlir::VectorType>($_self).getRank() > 0)"
78 // CHECK-NEXT: %[[v6:[^ ]*]] = irdl.all_of(%[[v4]], %[[v5]])
79 // CHECK-NEXT: %[[v7:[^ ]*]] = irdl.all_of(%[[v3]], %[[v6]])
80 // CHECK-NEXT: irdl.operands(tensor: %[[v2]], vector: %[[v7]])
81 // CHECK-NEXT: }
82
83 // Check generic integer types are converted correctly.
84 def Test_Integers : Test_Op<"integers"> {
85 let arguments = (ins AnyI8:$any_int,
86 AnyInteger:$any_integer);
87 }
88 // CHECK-LABEL: irdl.operation @integers {
89 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.is i8
90 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.is si8
91 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.is ui8
92 // CHECK-NEXT: %[[v3:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]], %[[v2]])
93 // CHECK-NEXT: %[[v4:[^ ]*]] = irdl.base "!builtin.integer"
94 // CHECK-NEXT: irdl.operands(any_int: %[[v3]], any_integer: %[[v4]])
95 // CHECK-NEXT: }
96
97 // Check that IRDL names are properly generated when needed.
98 def Test_NamesOp : Test_Op<"names"> {
99 let arguments = (ins I32:$a,
100 I32:$hello,
101 I32:$unnamed0,
102 I32);
103 let regions = (region AnyRegion:$unnamed1);
104 let results = (outs I32:$unnamed2);
105 }
106 // CHECK-LABEL: irdl.operation @names {
107 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.is i32
108 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.is i32
109 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.is i32
110 // CHECK-NEXT: %[[v3:[^ ]*]] = irdl.is i32
111 // CHECK-NEXT: %[[v4:[^ ]*]] = irdl.is i32
112 // CHECK-NEXT: %[[reg:[^ ]*]] = irdl.region
113 // CHECK-NEXT: irdl.operands(a: %[[v0]], hello: %[[v1]], unnamed0: %[[v2]], unnamed3: %[[v3]])
114 // CHECK-NEXT: irdl.results(unnamed2: %[[v4]])
115 // CHECK-NEXT: irdl.regions(unnamed1: %[[reg]])
116 // CHECK-NEXT: }
117
118 // Check that AnyTypeOf is converted correctly.
119 def Test_OrOp : Test_Op<"or"> {
120 let arguments = (ins AnyTypeOf<[Test_SingletonAType, Test_SingletonBType, Test_SingletonCType]>:$in);
121 }
122 // CHECK-LABEL: irdl.operation @or {
123 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.base @test::@"!singleton_a"
124 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.base @test::@"!singleton_b"
125 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.base @test::@"!singleton_c"
126 // CHECK-NEXT: %[[v3:[^ ]*]] = irdl.any_of(%[[v0]], %[[v1]], %[[v2]])
127 // CHECK-NEXT: irdl.operands(in: %[[v3]])
128 // CHECK-NEXT: }
129
130 // Check regions are converted correctly.
131 def Test_RegionsOp : Test_Op<"regions"> {
132 let regions = (region AnyRegion:$any_region,
133 SizedRegion<1>:$single_block_region);
134 }
135 // CHECK-LABEL: irdl.operation @regions {
136 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.region
137 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.region with size 1
138 // CHECK-NEXT: irdl.regions(any_region: %[[v0]], single_block_region: %[[v1]])
139 // CHECK-NEXT: }
140
141 // Check that various types are converted correctly.
142 def Test_TypesOp : Test_Op<"types"> {
143 let arguments = (ins I32:$a,
144 SI64:$b,
145 UI8:$c,
146 Index:$d,
147 F32:$e,
148 NoneType:$f,
149 Complex<F8E4M3FN>);
150 }
151 // CHECK-LABEL: irdl.operation @types {
152 // CHECK-NEXT: %{{.*}} = irdl.is i32
153 // CHECK-NEXT: %{{.*}} = irdl.is si64
154 // CHECK-NEXT: %{{.*}} = irdl.is ui8
155 // CHECK-NEXT: %{{.*}} = irdl.is index
156 // CHECK-NEXT: %{{.*}} = irdl.is f32
157 // CHECK-NEXT: %{{.*}} = irdl.is none
158 // CHECK-NEXT: %{{.*}} = irdl.is complex<f8E4M3FN>
159 // CHECK-NEXT: irdl.operands({{.*}})
160 // CHECK-NEXT: }
161
162 // Check that variadics and optionals are converted correctly.
163 def Test_VariadicityOp : Test_Op<"variadicity"> {
164 let arguments = (ins Variadic<Test_SingletonAType>:$variadic,
165 Optional<Test_SingletonBType>:$optional,
166 Test_SingletonCType:$required);
167 }
168 // CHECK-LABEL: irdl.operation @variadicity {
169 // CHECK-NEXT: %[[v0:[^ ]*]] = irdl.base @test::@"!singleton_a"
170 // CHECK-NEXT: %[[v1:[^ ]*]] = irdl.base @test::@"!singleton_b"
171 // CHECK-NEXT: %[[v2:[^ ]*]] = irdl.base @test::@"!singleton_c"
172 // CHECK-NEXT: irdl.operands(variadic: variadic %[[v0]], optional: optional %[[v1]], required: %[[v2]])
173 // CHECK-NEXT: }