1 | //===- OperationSupportTest.cpp - Operation support unit tests ------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "mlir/IR/OperationSupport.h" |
10 | #include "../../test/lib/Dialect/Test/TestDialect.h" |
11 | #include "../../test/lib/Dialect/Test/TestOps.h" |
12 | #include "mlir/IR/Builders.h" |
13 | #include "mlir/IR/BuiltinTypes.h" |
14 | #include "llvm/ADT/BitVector.h" |
15 | #include "llvm/Support/FormatVariadic.h" |
16 | #include "gtest/gtest.h" |
17 | |
18 | using namespace mlir; |
19 | using namespace mlir::detail; |
20 | |
21 | static Operation *createOp(MLIRContext *context, |
22 | ArrayRef<Value> operands = std::nullopt, |
23 | ArrayRef<Type> resultTypes = std::nullopt, |
24 | unsigned int numRegions = 0) { |
25 | context->allowUnregisteredDialects(); |
26 | return Operation::create( |
27 | UnknownLoc::get(context), OperationName("foo.bar" , context), resultTypes, |
28 | operands, std::nullopt, nullptr, std::nullopt, numRegions); |
29 | } |
30 | |
31 | namespace { |
32 | TEST(OperandStorageTest, NonResizable) { |
33 | MLIRContext context; |
34 | Builder builder(&context); |
35 | |
36 | Operation *useOp = |
37 | createOp(&context, /*operands=*/std::nullopt, builder.getIntegerType(16)); |
38 | Value operand = useOp->getResult(idx: 0); |
39 | |
40 | // Create a non-resizable operation with one operand. |
41 | Operation *user = createOp(context: &context, operands: operand); |
42 | |
43 | // The same number of operands is okay. |
44 | user->setOperands(operand); |
45 | EXPECT_EQ(user->getNumOperands(), 1u); |
46 | |
47 | // Removing is okay. |
48 | user->setOperands(std::nullopt); |
49 | EXPECT_EQ(user->getNumOperands(), 0u); |
50 | |
51 | // Destroy the operations. |
52 | user->destroy(); |
53 | useOp->destroy(); |
54 | } |
55 | |
56 | TEST(OperandStorageTest, Resizable) { |
57 | MLIRContext context; |
58 | Builder builder(&context); |
59 | |
60 | Operation *useOp = |
61 | createOp(&context, /*operands=*/std::nullopt, builder.getIntegerType(16)); |
62 | Value operand = useOp->getResult(idx: 0); |
63 | |
64 | // Create a resizable operation with one operand. |
65 | Operation *user = createOp(context: &context, operands: operand); |
66 | |
67 | // The same number of operands is okay. |
68 | user->setOperands(operand); |
69 | EXPECT_EQ(user->getNumOperands(), 1u); |
70 | |
71 | // Removing is okay. |
72 | user->setOperands(std::nullopt); |
73 | EXPECT_EQ(user->getNumOperands(), 0u); |
74 | |
75 | // Adding more operands is okay. |
76 | user->setOperands({operand, operand, operand}); |
77 | EXPECT_EQ(user->getNumOperands(), 3u); |
78 | |
79 | // Destroy the operations. |
80 | user->destroy(); |
81 | useOp->destroy(); |
82 | } |
83 | |
84 | TEST(OperandStorageTest, RangeReplace) { |
85 | MLIRContext context; |
86 | Builder builder(&context); |
87 | |
88 | Operation *useOp = |
89 | createOp(&context, /*operands=*/std::nullopt, builder.getIntegerType(16)); |
90 | Value operand = useOp->getResult(idx: 0); |
91 | |
92 | // Create a resizable operation with one operand. |
93 | Operation *user = createOp(context: &context, operands: operand); |
94 | |
95 | // Check setting with the same number of operands. |
96 | user->setOperands(/*start=*/0, /*length=*/1, operands: operand); |
97 | EXPECT_EQ(user->getNumOperands(), 1u); |
98 | |
99 | // Check setting with more operands. |
100 | user->setOperands(/*start=*/0, /*length=*/1, operands: {operand, operand, operand}); |
101 | EXPECT_EQ(user->getNumOperands(), 3u); |
102 | |
103 | // Check setting with less operands. |
104 | user->setOperands(/*start=*/1, /*length=*/2, operands: {operand}); |
105 | EXPECT_EQ(user->getNumOperands(), 2u); |
106 | |
107 | // Check inserting without replacing operands. |
108 | user->setOperands(/*start=*/2, /*length=*/0, operands: {operand}); |
109 | EXPECT_EQ(user->getNumOperands(), 3u); |
110 | |
111 | // Check erasing operands. |
112 | user->setOperands(/*start=*/0, /*length=*/3, operands: {}); |
113 | EXPECT_EQ(user->getNumOperands(), 0u); |
114 | |
115 | // Destroy the operations. |
116 | user->destroy(); |
117 | useOp->destroy(); |
118 | } |
119 | |
120 | TEST(OperandStorageTest, MutableRange) { |
121 | MLIRContext context; |
122 | Builder builder(&context); |
123 | |
124 | Operation *useOp = |
125 | createOp(&context, /*operands=*/std::nullopt, builder.getIntegerType(16)); |
126 | Value operand = useOp->getResult(idx: 0); |
127 | |
128 | // Create a resizable operation with one operand. |
129 | Operation *user = createOp(context: &context, operands: operand); |
130 | |
131 | // Check setting with the same number of operands. |
132 | MutableOperandRange mutableOperands(user); |
133 | mutableOperands.assign(value: operand); |
134 | EXPECT_EQ(mutableOperands.size(), 1u); |
135 | EXPECT_EQ(user->getNumOperands(), 1u); |
136 | |
137 | // Check setting with more operands. |
138 | mutableOperands.assign(values: {operand, operand, operand}); |
139 | EXPECT_EQ(mutableOperands.size(), 3u); |
140 | EXPECT_EQ(user->getNumOperands(), 3u); |
141 | |
142 | // Check with inserting a new operand. |
143 | mutableOperands.append(values: {operand, operand}); |
144 | EXPECT_EQ(mutableOperands.size(), 5u); |
145 | EXPECT_EQ(user->getNumOperands(), 5u); |
146 | |
147 | // Check erasing operands. |
148 | mutableOperands.clear(); |
149 | EXPECT_EQ(mutableOperands.size(), 0u); |
150 | EXPECT_EQ(user->getNumOperands(), 0u); |
151 | |
152 | // Destroy the operations. |
153 | user->destroy(); |
154 | useOp->destroy(); |
155 | } |
156 | |
157 | TEST(OperandStorageTest, RangeErase) { |
158 | MLIRContext context; |
159 | Builder builder(&context); |
160 | |
161 | Type type = builder.getNoneType(); |
162 | Operation *useOp = |
163 | createOp(context: &context, /*operands=*/std::nullopt, resultTypes: {type, type}); |
164 | Value operand1 = useOp->getResult(idx: 0); |
165 | Value operand2 = useOp->getResult(idx: 1); |
166 | |
167 | // Create an operation with operands to erase. |
168 | Operation *user = |
169 | createOp(context: &context, operands: {operand2, operand1, operand2, operand1}); |
170 | BitVector eraseIndices(user->getNumOperands()); |
171 | |
172 | // Check erasing no operands. |
173 | user->eraseOperands(eraseIndices); |
174 | EXPECT_EQ(user->getNumOperands(), 4u); |
175 | |
176 | // Check erasing disjoint operands. |
177 | eraseIndices.set(0); |
178 | eraseIndices.set(3); |
179 | user->eraseOperands(eraseIndices); |
180 | EXPECT_EQ(user->getNumOperands(), 2u); |
181 | EXPECT_EQ(user->getOperand(0), operand1); |
182 | EXPECT_EQ(user->getOperand(1), operand2); |
183 | |
184 | // Destroy the operations. |
185 | user->destroy(); |
186 | useOp->destroy(); |
187 | } |
188 | |
189 | TEST(OperationOrderTest, OrderIsAlwaysValid) { |
190 | MLIRContext context; |
191 | Builder builder(&context); |
192 | |
193 | Operation *containerOp = createOp(context: &context, /*operands=*/std::nullopt, |
194 | /*resultTypes=*/std::nullopt, |
195 | /*numRegions=*/1); |
196 | Region ®ion = containerOp->getRegion(index: 0); |
197 | Block *block = new Block(); |
198 | region.push_back(block); |
199 | |
200 | // Insert two operations, then iteratively add more operations in the middle |
201 | // of them. Eventually we will insert more than kOrderStride operations and |
202 | // the block order will need to be recomputed. |
203 | Operation *frontOp = createOp(context: &context); |
204 | Operation *backOp = createOp(context: &context); |
205 | block->push_back(op: frontOp); |
206 | block->push_back(op: backOp); |
207 | |
208 | // Chosen to be larger than Operation::kOrderStride. |
209 | int kNumOpsToInsert = 10; |
210 | for (int i = 0; i < kNumOpsToInsert; ++i) { |
211 | Operation *op = createOp(context: &context); |
212 | block->getOperations().insert(backOp->getIterator(), op); |
213 | ASSERT_TRUE(op->isBeforeInBlock(backOp)); |
214 | // Note verifyOpOrder() returns false if the order is valid. |
215 | ASSERT_FALSE(block->verifyOpOrder()); |
216 | } |
217 | |
218 | containerOp->destroy(); |
219 | } |
220 | |
221 | TEST(OperationFormatPrintTest, CanUseVariadicFormat) { |
222 | MLIRContext context; |
223 | Builder builder(&context); |
224 | |
225 | Operation *op = createOp(context: &context); |
226 | |
227 | std::string str = formatv(Fmt: "{0}" , Vals&: *op).str(); |
228 | ASSERT_STREQ(str.c_str(), "\"foo.bar\"() : () -> ()" ); |
229 | |
230 | op->destroy(); |
231 | } |
232 | |
233 | TEST(OperationFormatPrintTest, CanPrintNameAsPrefix) { |
234 | MLIRContext context; |
235 | Builder builder(&context); |
236 | |
237 | context.allowUnregisteredDialects(); |
238 | Operation *op = Operation::create( |
239 | NameLoc::get(StringAttr::get(&context, "my_named_loc" )), |
240 | OperationName("t.op" , &context), builder.getIntegerType(16), std::nullopt, |
241 | std::nullopt, nullptr, std::nullopt, 0); |
242 | |
243 | std::string str; |
244 | OpPrintingFlags flags; |
245 | flags.printNameLocAsPrefix(enable: true); |
246 | llvm::raw_string_ostream os(str); |
247 | op->print(os, flags); |
248 | ASSERT_STREQ(str.c_str(), "%my_named_loc = \"t.op\"() : () -> i16\n" ); |
249 | |
250 | op->destroy(); |
251 | } |
252 | |
253 | TEST(NamedAttrListTest, TestAppendAssign) { |
254 | MLIRContext ctx; |
255 | NamedAttrList attrs; |
256 | Builder b(&ctx); |
257 | |
258 | attrs.append(b.getStringAttr("foo" ), b.getStringAttr("bar" )); |
259 | attrs.append("baz" , b.getStringAttr("boo" )); |
260 | |
261 | { |
262 | auto *it = attrs.begin(); |
263 | EXPECT_EQ(it->getName(), b.getStringAttr("foo" )); |
264 | EXPECT_EQ(it->getValue(), b.getStringAttr("bar" )); |
265 | ++it; |
266 | EXPECT_EQ(it->getName(), b.getStringAttr("baz" )); |
267 | EXPECT_EQ(it->getValue(), b.getStringAttr("boo" )); |
268 | } |
269 | |
270 | attrs.append("foo" , b.getStringAttr("zoo" )); |
271 | { |
272 | auto dup = attrs.findDuplicate(); |
273 | ASSERT_TRUE(dup.has_value()); |
274 | } |
275 | |
276 | SmallVector<NamedAttribute> newAttrs = { |
277 | b.getNamedAttr("foo" , b.getStringAttr("f" )), |
278 | b.getNamedAttr("zoo" , b.getStringAttr("z" )), |
279 | }; |
280 | attrs.assign(range: newAttrs); |
281 | |
282 | auto dup = attrs.findDuplicate(); |
283 | ASSERT_FALSE(dup.has_value()); |
284 | |
285 | { |
286 | auto *it = attrs.begin(); |
287 | EXPECT_EQ(it->getName(), b.getStringAttr("foo" )); |
288 | EXPECT_EQ(it->getValue(), b.getStringAttr("f" )); |
289 | ++it; |
290 | EXPECT_EQ(it->getName(), b.getStringAttr("zoo" )); |
291 | EXPECT_EQ(it->getValue(), b.getStringAttr("z" )); |
292 | } |
293 | |
294 | attrs.assign(range: {}); |
295 | ASSERT_TRUE(attrs.empty()); |
296 | } |
297 | |
298 | TEST(OperandStorageTest, PopulateDefaultAttrs) { |
299 | MLIRContext context; |
300 | context.getOrLoadDialect<test::TestDialect>(); |
301 | Builder builder(&context); |
302 | |
303 | OpBuilder b(&context); |
304 | auto req1 = b.getI32IntegerAttr(10); |
305 | auto req2 = b.getI32IntegerAttr(60); |
306 | // Verify default attributes populated post op creation. |
307 | Operation *op = b.create<test::OpAttrMatch1>(b.getUnknownLoc(), req1, nullptr, |
308 | nullptr, req2); |
309 | auto opt = op->getInherentAttr(name: "default_valued_attr" ); |
310 | EXPECT_NE(opt, nullptr) << *op; |
311 | |
312 | op->destroy(); |
313 | } |
314 | |
315 | TEST(OperationEquivalenceTest, HashWorksWithFlags) { |
316 | MLIRContext context; |
317 | context.getOrLoadDialect<test::TestDialect>(); |
318 | OpBuilder b(&context); |
319 | |
320 | auto *op1 = createOp(context: &context); |
321 | // `op1` has an unknown loc. |
322 | auto *op2 = createOp(context: &context); |
323 | op2->setLoc(NameLoc::get(StringAttr::get(&context, "foo" ))); |
324 | auto getHash = [](Operation *op, OperationEquivalence::Flags flags) { |
325 | return OperationEquivalence::computeHash( |
326 | op, hashOperands: OperationEquivalence::ignoreHashValue, |
327 | hashResults: OperationEquivalence::ignoreHashValue, flags); |
328 | }; |
329 | // Check ignore location. |
330 | EXPECT_EQ(getHash(op1, OperationEquivalence::IgnoreLocations), |
331 | getHash(op2, OperationEquivalence::IgnoreLocations)); |
332 | EXPECT_NE(getHash(op1, OperationEquivalence::None), |
333 | getHash(op2, OperationEquivalence::None)); |
334 | op1->setLoc(NameLoc::get(StringAttr::get(&context, "foo" ))); |
335 | // Check ignore discardable dictionary attributes. |
336 | SmallVector<NamedAttribute> newAttrs = { |
337 | b.getNamedAttr("foo" , b.getStringAttr("f" ))}; |
338 | op1->setAttrs(newAttrs); |
339 | EXPECT_EQ(getHash(op1, OperationEquivalence::IgnoreDiscardableAttrs), |
340 | getHash(op2, OperationEquivalence::IgnoreDiscardableAttrs)); |
341 | EXPECT_NE(getHash(op1, OperationEquivalence::None), |
342 | getHash(op2, OperationEquivalence::None)); |
343 | op1->destroy(); |
344 | op2->destroy(); |
345 | |
346 | // Check ignore properties. |
347 | auto req1 = b.getI32IntegerAttr(10); |
348 | Operation *opWithProperty1 = b.create<test::OpAttrMatch1>( |
349 | b.getUnknownLoc(), req1, nullptr, nullptr, req1); |
350 | auto req2 = b.getI32IntegerAttr(60); |
351 | Operation *opWithProperty2 = b.create<test::OpAttrMatch1>( |
352 | b.getUnknownLoc(), req2, nullptr, nullptr, req2); |
353 | EXPECT_EQ(getHash(opWithProperty1, OperationEquivalence::IgnoreProperties), |
354 | getHash(opWithProperty2, OperationEquivalence::IgnoreProperties)); |
355 | EXPECT_NE(getHash(opWithProperty1, OperationEquivalence::None), |
356 | getHash(opWithProperty2, OperationEquivalence::None)); |
357 | opWithProperty1->destroy(); |
358 | opWithProperty2->destroy(); |
359 | } |
360 | |
361 | } // namespace |
362 | |