1 //===- pdl.c - Test of PDL dialect C API ----------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
4 // Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9
10 // RUN: mlir-capi-pdl-test 2>&1 | FileCheck %s
11
12 #include "mlir-c/Dialect/PDL.h"
13 #include "mlir-c/BuiltinTypes.h"
14 #include "mlir-c/IR.h"
15
16 #include <assert.h>
17 #include <inttypes.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20
21 // CHECK-LABEL: testAttributeType
testAttributeType(MlirContext ctx)22 void testAttributeType(MlirContext ctx) {
23 fprintf(stderr, "testAttributeType\n");
24
25 MlirType parsedType = mlirTypeParseGet(
26 ctx, mlirStringRefCreateFromCString("!pdl.attribute"));
27 MlirType constructedType = mlirPDLAttributeTypeGet(ctx);
28
29 assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
30 assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
31
32 // CHECK: parsedType isa PDLType: 1
33 fprintf(stderr, "parsedType isa PDLType: %d\n",
34 mlirTypeIsAPDLType(parsedType));
35 // CHECK: parsedType isa PDLAttributeType: 1
36 fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
37 mlirTypeIsAPDLAttributeType(parsedType));
38 // CHECK: parsedType isa PDLOperationType: 0
39 fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
40 mlirTypeIsAPDLOperationType(parsedType));
41 // CHECK: parsedType isa PDLRangeType: 0
42 fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
43 mlirTypeIsAPDLRangeType(parsedType));
44 // CHECK: parsedType isa PDLTypeType: 0
45 fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
46 mlirTypeIsAPDLTypeType(parsedType));
47 // CHECK: parsedType isa PDLValueType: 0
48 fprintf(stderr, "parsedType isa PDLValueType: %d\n",
49 mlirTypeIsAPDLValueType(parsedType));
50
51 // CHECK: constructedType isa PDLType: 1
52 fprintf(stderr, "constructedType isa PDLType: %d\n",
53 mlirTypeIsAPDLType(constructedType));
54 // CHECK: constructedType isa PDLAttributeType: 1
55 fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
56 mlirTypeIsAPDLAttributeType(constructedType));
57 // CHECK: constructedType isa PDLOperationType: 0
58 fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
59 mlirTypeIsAPDLOperationType(constructedType));
60 // CHECK: constructedType isa PDLRangeType: 0
61 fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
62 mlirTypeIsAPDLRangeType(constructedType));
63 // CHECK: constructedType isa PDLTypeType: 0
64 fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
65 mlirTypeIsAPDLTypeType(constructedType));
66 // CHECK: constructedType isa PDLValueType: 0
67 fprintf(stderr, "constructedType isa PDLValueType: %d\n",
68 mlirTypeIsAPDLValueType(constructedType));
69
70 // CHECK: equal: 1
71 fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
72
73 // CHECK: !pdl.attribute
74 mlirTypeDump(parsedType);
75 // CHECK: !pdl.attribute
76 mlirTypeDump(constructedType);
77
78 fprintf(stderr, "\n\n");
79 }
80
81 // CHECK-LABEL: testOperationType
testOperationType(MlirContext ctx)82 void testOperationType(MlirContext ctx) {
83 fprintf(stderr, "testOperationType\n");
84
85 MlirType parsedType = mlirTypeParseGet(
86 ctx, mlirStringRefCreateFromCString("!pdl.operation"));
87 MlirType constructedType = mlirPDLOperationTypeGet(ctx);
88
89 assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
90 assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
91
92 // CHECK: parsedType isa PDLType: 1
93 fprintf(stderr, "parsedType isa PDLType: %d\n",
94 mlirTypeIsAPDLType(parsedType));
95 // CHECK: parsedType isa PDLAttributeType: 0
96 fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
97 mlirTypeIsAPDLAttributeType(parsedType));
98 // CHECK: parsedType isa PDLOperationType: 1
99 fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
100 mlirTypeIsAPDLOperationType(parsedType));
101 // CHECK: parsedType isa PDLRangeType: 0
102 fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
103 mlirTypeIsAPDLRangeType(parsedType));
104 // CHECK: parsedType isa PDLTypeType: 0
105 fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
106 mlirTypeIsAPDLTypeType(parsedType));
107 // CHECK: parsedType isa PDLValueType: 0
108 fprintf(stderr, "parsedType isa PDLValueType: %d\n",
109 mlirTypeIsAPDLValueType(parsedType));
110
111 // CHECK: constructedType isa PDLType: 1
112 fprintf(stderr, "constructedType isa PDLType: %d\n",
113 mlirTypeIsAPDLType(constructedType));
114 // CHECK: constructedType isa PDLAttributeType: 0
115 fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
116 mlirTypeIsAPDLAttributeType(constructedType));
117 // CHECK: constructedType isa PDLOperationType: 1
118 fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
119 mlirTypeIsAPDLOperationType(constructedType));
120 // CHECK: constructedType isa PDLRangeType: 0
121 fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
122 mlirTypeIsAPDLRangeType(constructedType));
123 // CHECK: constructedType isa PDLTypeType: 0
124 fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
125 mlirTypeIsAPDLTypeType(constructedType));
126 // CHECK: constructedType isa PDLValueType: 0
127 fprintf(stderr, "constructedType isa PDLValueType: %d\n",
128 mlirTypeIsAPDLValueType(constructedType));
129
130 // CHECK: equal: 1
131 fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
132
133 // CHECK: !pdl.operation
134 mlirTypeDump(parsedType);
135 // CHECK: !pdl.operation
136 mlirTypeDump(constructedType);
137
138 fprintf(stderr, "\n\n");
139 }
140
141 // CHECK-LABEL: testRangeType
testRangeType(MlirContext ctx)142 void testRangeType(MlirContext ctx) {
143 fprintf(stderr, "testRangeType\n");
144
145 MlirType typeType = mlirPDLTypeTypeGet(ctx);
146 MlirType parsedType = mlirTypeParseGet(
147 ctx, mlirStringRefCreateFromCString("!pdl.range<type>"));
148 MlirType constructedType = mlirPDLRangeTypeGet(typeType);
149 MlirType elementType = mlirPDLRangeTypeGetElementType(constructedType);
150
151 assert(!mlirTypeIsNull(typeType) && "couldn't get PDLTypeType");
152 assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
153 assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
154
155 // CHECK: parsedType isa PDLType: 1
156 fprintf(stderr, "parsedType isa PDLType: %d\n",
157 mlirTypeIsAPDLType(parsedType));
158 // CHECK: parsedType isa PDLAttributeType: 0
159 fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
160 mlirTypeIsAPDLAttributeType(parsedType));
161 // CHECK: parsedType isa PDLOperationType: 0
162 fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
163 mlirTypeIsAPDLOperationType(parsedType));
164 // CHECK: parsedType isa PDLRangeType: 1
165 fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
166 mlirTypeIsAPDLRangeType(parsedType));
167 // CHECK: parsedType isa PDLTypeType: 0
168 fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
169 mlirTypeIsAPDLTypeType(parsedType));
170 // CHECK: parsedType isa PDLValueType: 0
171 fprintf(stderr, "parsedType isa PDLValueType: %d\n",
172 mlirTypeIsAPDLValueType(parsedType));
173
174 // CHECK: constructedType isa PDLType: 1
175 fprintf(stderr, "constructedType isa PDLType: %d\n",
176 mlirTypeIsAPDLType(constructedType));
177 // CHECK: constructedType isa PDLAttributeType: 0
178 fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
179 mlirTypeIsAPDLAttributeType(constructedType));
180 // CHECK: constructedType isa PDLOperationType: 0
181 fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
182 mlirTypeIsAPDLOperationType(constructedType));
183 // CHECK: constructedType isa PDLRangeType: 1
184 fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
185 mlirTypeIsAPDLRangeType(constructedType));
186 // CHECK: constructedType isa PDLTypeType: 0
187 fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
188 mlirTypeIsAPDLTypeType(constructedType));
189 // CHECK: constructedType isa PDLValueType: 0
190 fprintf(stderr, "constructedType isa PDLValueType: %d\n",
191 mlirTypeIsAPDLValueType(constructedType));
192
193 // CHECK: equal: 1
194 fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
195 // CHECK: equal: 1
196 fprintf(stderr, "equal: %d\n", mlirTypeEqual(typeType, elementType));
197
198 // CHECK: !pdl.range<type>
199 mlirTypeDump(parsedType);
200 // CHECK: !pdl.range<type>
201 mlirTypeDump(constructedType);
202 // CHECK: !pdl.type
203 mlirTypeDump(elementType);
204
205 fprintf(stderr, "\n\n");
206 }
207
208 // CHECK-LABEL: testTypeType
testTypeType(MlirContext ctx)209 void testTypeType(MlirContext ctx) {
210 fprintf(stderr, "testTypeType\n");
211
212 MlirType parsedType = mlirTypeParseGet(
213 ctx, mlirStringRefCreateFromCString("!pdl.type"));
214 MlirType constructedType = mlirPDLTypeTypeGet(ctx);
215
216 assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
217 assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
218
219 // CHECK: parsedType isa PDLType: 1
220 fprintf(stderr, "parsedType isa PDLType: %d\n",
221 mlirTypeIsAPDLType(parsedType));
222 // CHECK: parsedType isa PDLAttributeType: 0
223 fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
224 mlirTypeIsAPDLAttributeType(parsedType));
225 // CHECK: parsedType isa PDLOperationType: 0
226 fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
227 mlirTypeIsAPDLOperationType(parsedType));
228 // CHECK: parsedType isa PDLRangeType: 0
229 fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
230 mlirTypeIsAPDLRangeType(parsedType));
231 // CHECK: parsedType isa PDLTypeType: 1
232 fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
233 mlirTypeIsAPDLTypeType(parsedType));
234 // CHECK: parsedType isa PDLValueType: 0
235 fprintf(stderr, "parsedType isa PDLValueType: %d\n",
236 mlirTypeIsAPDLValueType(parsedType));
237
238 // CHECK: constructedType isa PDLType: 1
239 fprintf(stderr, "constructedType isa PDLType: %d\n",
240 mlirTypeIsAPDLType(constructedType));
241 // CHECK: constructedType isa PDLAttributeType: 0
242 fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
243 mlirTypeIsAPDLAttributeType(constructedType));
244 // CHECK: constructedType isa PDLOperationType: 0
245 fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
246 mlirTypeIsAPDLOperationType(constructedType));
247 // CHECK: constructedType isa PDLRangeType: 0
248 fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
249 mlirTypeIsAPDLRangeType(constructedType));
250 // CHECK: constructedType isa PDLTypeType: 1
251 fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
252 mlirTypeIsAPDLTypeType(constructedType));
253 // CHECK: constructedType isa PDLValueType: 0
254 fprintf(stderr, "constructedType isa PDLValueType: %d\n",
255 mlirTypeIsAPDLValueType(constructedType));
256
257 // CHECK: equal: 1
258 fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
259
260 // CHECK: !pdl.type
261 mlirTypeDump(parsedType);
262 // CHECK: !pdl.type
263 mlirTypeDump(constructedType);
264
265 fprintf(stderr, "\n\n");
266 }
267
268 // CHECK-LABEL: testValueType
testValueType(MlirContext ctx)269 void testValueType(MlirContext ctx) {
270 fprintf(stderr, "testValueType\n");
271
272 MlirType parsedType = mlirTypeParseGet(
273 ctx, mlirStringRefCreateFromCString("!pdl.value"));
274 MlirType constructedType = mlirPDLValueTypeGet(ctx);
275
276 assert(!mlirTypeIsNull(parsedType) && "couldn't parse PDLAttributeType");
277 assert(!mlirTypeIsNull(constructedType) && "couldn't construct PDLAttributeType");
278
279 // CHECK: parsedType isa PDLType: 1
280 fprintf(stderr, "parsedType isa PDLType: %d\n",
281 mlirTypeIsAPDLType(parsedType));
282 // CHECK: parsedType isa PDLAttributeType: 0
283 fprintf(stderr, "parsedType isa PDLAttributeType: %d\n",
284 mlirTypeIsAPDLAttributeType(parsedType));
285 // CHECK: parsedType isa PDLOperationType: 0
286 fprintf(stderr, "parsedType isa PDLOperationType: %d\n",
287 mlirTypeIsAPDLOperationType(parsedType));
288 // CHECK: parsedType isa PDLRangeType: 0
289 fprintf(stderr, "parsedType isa PDLRangeType: %d\n",
290 mlirTypeIsAPDLRangeType(parsedType));
291 // CHECK: parsedType isa PDLTypeType: 0
292 fprintf(stderr, "parsedType isa PDLTypeType: %d\n",
293 mlirTypeIsAPDLTypeType(parsedType));
294 // CHECK: parsedType isa PDLValueType: 1
295 fprintf(stderr, "parsedType isa PDLValueType: %d\n",
296 mlirTypeIsAPDLValueType(parsedType));
297
298 // CHECK: constructedType isa PDLType: 1
299 fprintf(stderr, "constructedType isa PDLType: %d\n",
300 mlirTypeIsAPDLType(constructedType));
301 // CHECK: constructedType isa PDLAttributeType: 0
302 fprintf(stderr, "constructedType isa PDLAttributeType: %d\n",
303 mlirTypeIsAPDLAttributeType(constructedType));
304 // CHECK: constructedType isa PDLOperationType: 0
305 fprintf(stderr, "constructedType isa PDLOperationType: %d\n",
306 mlirTypeIsAPDLOperationType(constructedType));
307 // CHECK: constructedType isa PDLRangeType: 0
308 fprintf(stderr, "constructedType isa PDLRangeType: %d\n",
309 mlirTypeIsAPDLRangeType(constructedType));
310 // CHECK: constructedType isa PDLTypeType: 0
311 fprintf(stderr, "constructedType isa PDLTypeType: %d\n",
312 mlirTypeIsAPDLTypeType(constructedType));
313 // CHECK: constructedType isa PDLValueType: 1
314 fprintf(stderr, "constructedType isa PDLValueType: %d\n",
315 mlirTypeIsAPDLValueType(constructedType));
316
317 // CHECK: equal: 1
318 fprintf(stderr, "equal: %d\n", mlirTypeEqual(parsedType, constructedType));
319
320 // CHECK: !pdl.value
321 mlirTypeDump(parsedType);
322 // CHECK: !pdl.value
323 mlirTypeDump(constructedType);
324
325 fprintf(stderr, "\n\n");
326 }
327
main(void)328 int main(void) {
329 MlirContext ctx = mlirContextCreate();
330 mlirDialectHandleRegisterDialect(mlirGetDialectHandle__pdl__(), ctx);
331 testAttributeType(ctx);
332 testOperationType(ctx);
333 testRangeType(ctx);
334 testTypeType(ctx);
335 testValueType(ctx);
336 mlirContextDestroy(ctx);
337 return EXIT_SUCCESS;
338 }
339