1//===- Builders.cpp - Helpers for constructing MLIR Classes ---------------===//
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/Builders.h"
10#include "mlir/IR/AffineExpr.h"
11#include "mlir/IR/AffineMap.h"
12#include "mlir/IR/BuiltinTypes.h"
13#include "mlir/IR/Dialect.h"
14#include "mlir/IR/IRMapping.h"
15#include "mlir/IR/Matchers.h"
16#include "llvm/ADT/SmallVectorExtras.h"
17#include "llvm/Support/DebugLog.h"
18
19using namespace mlir;
20
21//===----------------------------------------------------------------------===//
22// Locations.
23//===----------------------------------------------------------------------===//
24
25Location Builder::getUnknownLoc() { return UnknownLoc::get(context); }
26
27Location Builder::getFusedLoc(ArrayRef<Location> locs, Attribute metadata) {
28 return FusedLoc::get(locs, metadata, context);
29}
30
31//===----------------------------------------------------------------------===//
32// Types.
33//===----------------------------------------------------------------------===//
34
35FloatType Builder::getF8E8M0Type() { return Float8E8M0FNUType::get(ctx: context); }
36
37FloatType Builder::getF8E5M3FNUType() {
38 return Float8E5M3FNUType::get(ctx: context);
39}
40
41FloatType Builder::getF8E4M3FNType() { return Float8E4M3FNType::get(ctx: context); }
42
43FloatType Builder::getF8E5M2Type() { return Float8E5M2Type::get(ctx: context); }
44
45FloatType Builder::getBF16Type() { return BFloat16Type::get(context); }
46
47FloatType Builder::getF16Type() { return Float16Type::get(context); }
48
49FloatType Builder::getTF32Type() { return FloatTF32Type::get(context); }
50
51FloatType Builder::getF32Type() { return Float32Type::get(context); }
52
53FloatType Builder::getF64Type() { return Float64Type::get(context); }
54
55FloatType Builder::getF80Type() { return Float80Type::get(context); }
56
57FloatType Builder::getF128Type() { return Float128Type::get(context); }
58
59IndexType Builder::getIndexType() { return IndexType::get(context); }
60
61IntegerType Builder::getI1Type() { return IntegerType::get(context, width: 1); }
62
63IntegerType Builder::getI2Type() { return IntegerType::get(context, width: 2); }
64
65IntegerType Builder::getI4Type() { return IntegerType::get(context, width: 4); }
66
67IntegerType Builder::getI8Type() { return IntegerType::get(context, width: 8); }
68
69IntegerType Builder::getI16Type() { return IntegerType::get(context, width: 16); }
70
71IntegerType Builder::getI32Type() { return IntegerType::get(context, width: 32); }
72
73IntegerType Builder::getI64Type() { return IntegerType::get(context, width: 64); }
74
75IntegerType Builder::getIntegerType(unsigned width) {
76 return IntegerType::get(context, width);
77}
78
79IntegerType Builder::getIntegerType(unsigned width, bool isSigned) {
80 return IntegerType::get(
81 context, width, signedness: isSigned ? IntegerType::Signed : IntegerType::Unsigned);
82}
83
84FunctionType Builder::getFunctionType(TypeRange inputs, TypeRange results) {
85 return FunctionType::get(context, inputs, results);
86}
87
88GraphType Builder::getGraphType(TypeRange inputs, TypeRange results) {
89 return GraphType::get(context, inputs, results);
90}
91
92TupleType Builder::getTupleType(TypeRange elementTypes) {
93 return TupleType::get(context, elementTypes);
94}
95
96NoneType Builder::getNoneType() { return NoneType::get(context); }
97
98//===----------------------------------------------------------------------===//
99// Attributes.
100//===----------------------------------------------------------------------===//
101
102NamedAttribute Builder::getNamedAttr(StringRef name, Attribute val) {
103 return NamedAttribute(name, val);
104}
105
106UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); }
107
108BoolAttr Builder::getBoolAttr(bool value) {
109 return BoolAttr::get(context, value);
110}
111
112DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
113 return DictionaryAttr::get(context, value);
114}
115
116IntegerAttr Builder::getIndexAttr(int64_t value) {
117 return IntegerAttr::get(type: getIndexType(), value: APInt(64, value));
118}
119
120IntegerAttr Builder::getI64IntegerAttr(int64_t value) {
121 return IntegerAttr::get(type: getIntegerType(width: 64), value: APInt(64, value));
122}
123
124DenseIntElementsAttr Builder::getBoolVectorAttr(ArrayRef<bool> values) {
125 return DenseIntElementsAttr::get(
126 type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getI1Type()),
127 arg&: values);
128}
129
130DenseIntElementsAttr Builder::getI32VectorAttr(ArrayRef<int32_t> values) {
131 return DenseIntElementsAttr::get(
132 type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIntegerType(width: 32)),
133 arg&: values);
134}
135
136DenseIntElementsAttr Builder::getI64VectorAttr(ArrayRef<int64_t> values) {
137 return DenseIntElementsAttr::get(
138 type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIntegerType(width: 64)),
139 arg&: values);
140}
141
142DenseIntElementsAttr Builder::getIndexVectorAttr(ArrayRef<int64_t> values) {
143 return DenseIntElementsAttr::get(
144 type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIndexType()),
145 arg&: values);
146}
147
148DenseFPElementsAttr Builder::getF32VectorAttr(ArrayRef<float> values) {
149 return DenseFPElementsAttr::get(
150 type: VectorType::get(shape: static_cast<float>(values.size()), elementType: getF32Type()), arg&: values);
151}
152
153DenseFPElementsAttr Builder::getF64VectorAttr(ArrayRef<double> values) {
154 return DenseFPElementsAttr::get(
155 type: VectorType::get(shape: static_cast<double>(values.size()), elementType: getF64Type()),
156 arg&: values);
157}
158
159DenseBoolArrayAttr Builder::getDenseBoolArrayAttr(ArrayRef<bool> values) {
160 return DenseBoolArrayAttr::get(context, content: values);
161}
162
163DenseI8ArrayAttr Builder::getDenseI8ArrayAttr(ArrayRef<int8_t> values) {
164 return DenseI8ArrayAttr::get(context, content: values);
165}
166
167DenseI16ArrayAttr Builder::getDenseI16ArrayAttr(ArrayRef<int16_t> values) {
168 return DenseI16ArrayAttr::get(context, content: values);
169}
170
171DenseI32ArrayAttr Builder::getDenseI32ArrayAttr(ArrayRef<int32_t> values) {
172 return DenseI32ArrayAttr::get(context, content: values);
173}
174
175DenseI64ArrayAttr Builder::getDenseI64ArrayAttr(ArrayRef<int64_t> values) {
176 return DenseI64ArrayAttr::get(context, content: values);
177}
178
179DenseF32ArrayAttr Builder::getDenseF32ArrayAttr(ArrayRef<float> values) {
180 return DenseF32ArrayAttr::get(context, content: values);
181}
182
183DenseF64ArrayAttr Builder::getDenseF64ArrayAttr(ArrayRef<double> values) {
184 return DenseF64ArrayAttr::get(context, content: values);
185}
186
187DenseIntElementsAttr Builder::getI32TensorAttr(ArrayRef<int32_t> values) {
188 return DenseIntElementsAttr::get(
189 type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()),
190 elementType: getIntegerType(width: 32)),
191 arg&: values);
192}
193
194DenseIntElementsAttr Builder::getI64TensorAttr(ArrayRef<int64_t> values) {
195 return DenseIntElementsAttr::get(
196 type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()),
197 elementType: getIntegerType(width: 64)),
198 arg&: values);
199}
200
201DenseIntElementsAttr Builder::getIndexTensorAttr(ArrayRef<int64_t> values) {
202 return DenseIntElementsAttr::get(
203 type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()),
204 elementType: getIndexType()),
205 arg&: values);
206}
207
208IntegerAttr Builder::getI32IntegerAttr(int32_t value) {
209 // The APInt always uses isSigned=true here because we accept the value
210 // as int32_t.
211 return IntegerAttr::get(type: getIntegerType(width: 32),
212 value: APInt(32, value, /*isSigned=*/true));
213}
214
215IntegerAttr Builder::getSI32IntegerAttr(int32_t value) {
216 return IntegerAttr::get(type: getIntegerType(width: 32, /*isSigned=*/true),
217 value: APInt(32, value, /*isSigned=*/true));
218}
219
220IntegerAttr Builder::getUI32IntegerAttr(uint32_t value) {
221 return IntegerAttr::get(type: getIntegerType(width: 32, /*isSigned=*/false),
222 value: APInt(32, (uint64_t)value, /*isSigned=*/false));
223}
224
225IntegerAttr Builder::getI16IntegerAttr(int16_t value) {
226 return IntegerAttr::get(type: getIntegerType(width: 16),
227 value: APInt(16, value, /*isSigned=*/true));
228}
229
230IntegerAttr Builder::getI8IntegerAttr(int8_t value) {
231 // The APInt always uses isSigned=true here because we accept the value
232 // as int8_t.
233 return IntegerAttr::get(type: getIntegerType(width: 8),
234 value: APInt(8, value, /*isSigned=*/true));
235}
236
237IntegerAttr Builder::getIntegerAttr(Type type, int64_t value) {
238 if (type.isIndex())
239 return IntegerAttr::get(type, value: APInt(64, value));
240 // TODO: Avoid implicit trunc?
241 // See https://github.com/llvm/llvm-project/issues/112510.
242 return IntegerAttr::get(type, value: APInt(type.getIntOrFloatBitWidth(), value,
243 type.isSignedInteger(),
244 /*implicitTrunc=*/true));
245}
246
247IntegerAttr Builder::getIntegerAttr(Type type, const APInt &value) {
248 return IntegerAttr::get(type, value);
249}
250
251FloatAttr Builder::getF64FloatAttr(double value) {
252 return FloatAttr::get(type: getF64Type(), value: APFloat(value));
253}
254
255FloatAttr Builder::getF32FloatAttr(float value) {
256 return FloatAttr::get(type: getF32Type(), value: APFloat(value));
257}
258
259FloatAttr Builder::getF16FloatAttr(float value) {
260 return FloatAttr::get(type: getF16Type(), value);
261}
262
263FloatAttr Builder::getFloatAttr(Type type, double value) {
264 return FloatAttr::get(type, value);
265}
266
267FloatAttr Builder::getFloatAttr(Type type, const APFloat &value) {
268 return FloatAttr::get(type, value);
269}
270
271StringAttr Builder::getStringAttr(const Twine &bytes) {
272 return StringAttr::get(context, bytes);
273}
274
275ArrayAttr Builder::getArrayAttr(ArrayRef<Attribute> value) {
276 return ArrayAttr::get(context, value);
277}
278
279ArrayAttr Builder::getBoolArrayAttr(ArrayRef<bool> values) {
280 auto attrs = llvm::map_to_vector<8>(
281 C&: values, F: [this](bool v) -> Attribute { return getBoolAttr(value: v); });
282 return getArrayAttr(value: attrs);
283}
284
285ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {
286 auto attrs = llvm::map_to_vector<8>(
287 C&: values, F: [this](int32_t v) -> Attribute { return getI32IntegerAttr(value: v); });
288 return getArrayAttr(value: attrs);
289}
290ArrayAttr Builder::getI64ArrayAttr(ArrayRef<int64_t> values) {
291 auto attrs = llvm::map_to_vector<8>(
292 C&: values, F: [this](int64_t v) -> Attribute { return getI64IntegerAttr(value: v); });
293 return getArrayAttr(value: attrs);
294}
295
296ArrayAttr Builder::getIndexArrayAttr(ArrayRef<int64_t> values) {
297 auto attrs = llvm::map_to_vector<8>(C&: values, F: [this](int64_t v) -> Attribute {
298 return getIntegerAttr(type: IndexType::get(context: getContext()), value: v);
299 });
300 return getArrayAttr(value: attrs);
301}
302
303ArrayAttr Builder::getF32ArrayAttr(ArrayRef<float> values) {
304 auto attrs = llvm::map_to_vector<8>(
305 C&: values, F: [this](float v) -> Attribute { return getF32FloatAttr(value: v); });
306 return getArrayAttr(value: attrs);
307}
308
309ArrayAttr Builder::getF64ArrayAttr(ArrayRef<double> values) {
310 auto attrs = llvm::map_to_vector<8>(
311 C&: values, F: [this](double v) -> Attribute { return getF64FloatAttr(value: v); });
312 return getArrayAttr(value: attrs);
313}
314
315ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
316 auto attrs = llvm::map_to_vector<8>(
317 C&: values, F: [this](StringRef v) -> Attribute { return getStringAttr(bytes: v); });
318 return getArrayAttr(value: attrs);
319}
320
321ArrayAttr Builder::getTypeArrayAttr(TypeRange values) {
322 auto attrs = llvm::map_to_vector<8>(
323 C&: values, F: [](Type v) -> Attribute { return TypeAttr::get(type: v); });
324 return getArrayAttr(value: attrs);
325}
326
327ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
328 auto attrs = llvm::map_to_vector<8>(
329 C&: values, F: [](AffineMap v) -> Attribute { return AffineMapAttr::get(value: v); });
330 return getArrayAttr(value: attrs);
331}
332
333TypedAttr Builder::getZeroAttr(Type type) {
334 if (llvm::isa<FloatType>(Val: type))
335 return getFloatAttr(type, value: 0.0);
336 if (llvm::isa<IndexType>(Val: type))
337 return getIndexAttr(value: 0);
338 if (llvm::dyn_cast<IntegerType>(Val&: type))
339 return getIntegerAttr(type,
340 value: APInt(llvm::cast<IntegerType>(Val&: type).getWidth(), 0));
341 if (llvm::isa<RankedTensorType, VectorType>(Val: type)) {
342 auto vtType = llvm::cast<ShapedType>(Val&: type);
343 auto element = getZeroAttr(type: vtType.getElementType());
344 if (!element || !isa<DenseElementType>(Val: vtType.getElementType()))
345 return {};
346 return DenseElementsAttr::get(type: vtType, values: element);
347 }
348 return {};
349}
350
351TypedAttr Builder::getOneAttr(Type type) {
352 if (llvm::isa<FloatType>(Val: type))
353 return getFloatAttr(type, value: 1.0);
354 if (llvm::isa<IndexType>(Val: type))
355 return getIndexAttr(value: 1);
356 if (llvm::dyn_cast<IntegerType>(Val&: type))
357 return getIntegerAttr(type,
358 value: APInt(llvm::cast<IntegerType>(Val&: type).getWidth(), 1));
359 if (llvm::isa<RankedTensorType, VectorType>(Val: type)) {
360 auto vtType = llvm::cast<ShapedType>(Val&: type);
361 auto element = getOneAttr(type: vtType.getElementType());
362 if (!element || !isa<DenseElementType>(Val: vtType.getElementType()))
363 return {};
364 return DenseElementsAttr::get(type: vtType, values: element);
365 }
366 return {};
367}
368
369//===----------------------------------------------------------------------===//
370// Affine Expressions, Affine Maps, and Integer Sets.
371//===----------------------------------------------------------------------===//
372
373AffineExpr Builder::getAffineDimExpr(unsigned position) {
374 return mlir::getAffineDimExpr(position, context);
375}
376
377AffineExpr Builder::getAffineSymbolExpr(unsigned position) {
378 return mlir::getAffineSymbolExpr(position, context);
379}
380
381AffineExpr Builder::getAffineConstantExpr(int64_t constant) {
382 return mlir::getAffineConstantExpr(constant, context);
383}
384
385AffineMap Builder::getEmptyAffineMap() { return AffineMap::get(context); }
386
387AffineMap Builder::getConstantAffineMap(int64_t val) {
388 return AffineMap::get(/*dimCount=*/0, /*symbolCount=*/0,
389 result: getAffineConstantExpr(constant: val));
390}
391
392AffineMap Builder::getDimIdentityMap() {
393 return AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, result: getAffineDimExpr(position: 0));
394}
395
396AffineMap Builder::getMultiDimIdentityMap(unsigned rank) {
397 SmallVector<AffineExpr, 4> dimExprs;
398 dimExprs.reserve(N: rank);
399 for (unsigned i = 0; i < rank; ++i)
400 dimExprs.push_back(Elt: getAffineDimExpr(position: i));
401 return AffineMap::get(/*dimCount=*/rank, /*symbolCount=*/0, results: dimExprs,
402 context);
403}
404
405AffineMap Builder::getSymbolIdentityMap() {
406 return AffineMap::get(/*dimCount=*/0, /*symbolCount=*/1,
407 result: getAffineSymbolExpr(position: 0));
408}
409
410AffineMap Builder::getSingleDimShiftAffineMap(int64_t shift) {
411 // expr = d0 + shift.
412 auto expr = getAffineDimExpr(position: 0) + shift;
413 return AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, result: expr);
414}
415
416AffineMap Builder::getShiftedAffineMap(AffineMap map, int64_t shift) {
417 SmallVector<AffineExpr, 4> shiftedResults;
418 shiftedResults.reserve(N: map.getNumResults());
419 for (auto resultExpr : map.getResults())
420 shiftedResults.push_back(Elt: resultExpr + shift);
421 return AffineMap::get(dimCount: map.getNumDims(), symbolCount: map.getNumSymbols(), results: shiftedResults,
422 context);
423}
424
425//===----------------------------------------------------------------------===//
426// OpBuilder
427//===----------------------------------------------------------------------===//
428
429/// Insert the given operation at the current insertion point and return it.
430Operation *OpBuilder::insert(Operation *op) {
431 if (block) {
432 block->getOperations().insert(where: insertPoint, New: op);
433 if (listener)
434 listener->notifyOperationInserted(op, /*previous=*/{});
435 }
436 return op;
437}
438
439Block *OpBuilder::createBlock(Region *parent, Region::iterator insertPt,
440 TypeRange argTypes, ArrayRef<Location> locs) {
441 assert(parent && "expected valid parent region");
442 assert(argTypes.size() == locs.size() && "argument location mismatch");
443 if (insertPt == Region::iterator())
444 insertPt = parent->end();
445
446 Block *b = new Block();
447 b->addArguments(types: argTypes, locs);
448 parent->getBlocks().insert(where: insertPt, New: b);
449 setInsertionPointToEnd(b);
450
451 if (listener)
452 listener->notifyBlockInserted(block: b, /*previous=*/nullptr, /*previousIt=*/{});
453 return b;
454}
455
456/// Add new block with 'argTypes' arguments and set the insertion point to the
457/// end of it. The block is placed before 'insertBefore'.
458Block *OpBuilder::createBlock(Block *insertBefore, TypeRange argTypes,
459 ArrayRef<Location> locs) {
460 assert(insertBefore && "expected valid insertion block");
461 return createBlock(parent: insertBefore->getParent(), insertPt: Region::iterator(insertBefore),
462 argTypes, locs);
463}
464
465/// Create an operation given the fields represented as an OperationState.
466Operation *OpBuilder::create(const OperationState &state) {
467 return insert(op: Operation::create(state));
468}
469
470/// Creates an operation with the given fields.
471Operation *OpBuilder::create(Location loc, StringAttr opName,
472 ValueRange operands, TypeRange types,
473 ArrayRef<NamedAttribute> attributes,
474 BlockRange successors,
475 MutableArrayRef<std::unique_ptr<Region>> regions) {
476 OperationState state(loc, opName, operands, types, attributes, successors,
477 regions);
478 return create(state);
479}
480
481LogicalResult
482OpBuilder::tryFold(Operation *op, SmallVectorImpl<Value> &results,
483 SmallVectorImpl<Operation *> *materializedConstants) {
484 assert(results.empty() && "expected empty results");
485 ResultRange opResults = op->getResults();
486
487 results.reserve(N: opResults.size());
488 auto cleanupFailure = [&] {
489 results.clear();
490 return failure();
491 };
492
493 // If this operation is already a constant, there is nothing to do.
494 if (matchPattern(op, pattern: m_Constant()))
495 return cleanupFailure();
496
497 // Try to fold the operation.
498 SmallVector<OpFoldResult, 4> foldResults;
499 LDBG() << "Trying to fold: "
500 << OpWithFlags(op, OpPrintingFlags().skipRegions());
501 if (failed(Result: op->fold(results&: foldResults)))
502 return cleanupFailure();
503
504 // Bound the number of in-place fold iterations. Legitimate chains are very
505 // short (e.g. foldCommutative swaps once, then the op folds to a value).
506 // Without a bound, circular SSA uses in graph regions can cause an infinite
507 // loop (e.g. addi(x, 0) where x is the op's own result).
508 constexpr int kMaxInPlaceFolds = 64;
509 int count = 0;
510 do {
511 LDBG() << "Folded in place #" << count
512 << " times: " << OpWithFlags(op, OpPrintingFlags().skipRegions());
513 if (++count >= kMaxInPlaceFolds) {
514 LDBG() << "Aborting after " << kMaxInPlaceFolds
515 << " in-place fold iterations: "
516 << OpWithFlags(op, OpPrintingFlags().skipRegions());
517 return cleanupFailure();
518 }
519 } while (foldResults.empty() && succeeded(Result: op->fold(results&: foldResults)));
520
521 // An in-place fold does not require generation of any constants.
522 if (foldResults.empty())
523 return success();
524
525 // A temporary builder used for creating constants during folding.
526 OpBuilder cstBuilder(context);
527 SmallVector<Operation *, 1> generatedConstants;
528
529 // Populate the results with the folded results.
530 Dialect *dialect = op->getDialect();
531 for (auto [foldResult, expectedType] :
532 llvm::zip_equal(t&: foldResults, u: opResults.getTypes())) {
533
534 // Normal values get pushed back directly.
535 if (auto value = llvm::dyn_cast_if_present<Value>(Val&: foldResult)) {
536 results.push_back(Elt: value);
537 continue;
538 }
539
540 // Otherwise, try to materialize a constant operation.
541 if (!dialect)
542 return cleanupFailure();
543
544 // Ask the dialect to materialize a constant operation for this value.
545 Attribute attr = cast<Attribute>(Val&: foldResult);
546 auto *constOp = dialect->materializeConstant(builder&: cstBuilder, value: attr, type: expectedType,
547 loc: op->getLoc());
548 if (!constOp) {
549 // Erase any generated constants.
550 for (Operation *cst : generatedConstants)
551 cst->erase();
552 return cleanupFailure();
553 }
554 assert(matchPattern(constOp, m_Constant()));
555
556 generatedConstants.push_back(Elt: constOp);
557 results.push_back(Elt: constOp->getResult(idx: 0));
558 }
559
560 // If we were successful, insert any generated constants.
561 for (Operation *cst : generatedConstants)
562 insert(op: cst);
563
564 // Return materialized constant operations.
565 if (materializedConstants)
566 *materializedConstants = std::move(generatedConstants);
567
568 return success();
569}
570
571/// Helper function that sends block insertion notifications for every block
572/// that is directly nested in the given op.
573static void notifyBlockInsertions(Operation *op,
574 OpBuilder::Listener *listener) {
575 for (Region &r : op->getRegions())
576 for (Block &b : r.getBlocks())
577 listener->notifyBlockInserted(block: &b, /*previous=*/nullptr,
578 /*previousIt=*/{});
579}
580
581Operation *OpBuilder::clone(Operation &op, IRMapping &mapper) {
582 Operation *newOp = op.clone(mapper);
583 newOp = insert(op: newOp);
584
585 // The `insert` call above handles the notification for inserting `newOp`
586 // itself. But if `newOp` has any regions, we need to notify the listener
587 // about any ops that got inserted inside those regions as part of cloning.
588 if (listener) {
589 // The `insert` call above notifies about op insertion, but not about block
590 // insertion.
591 notifyBlockInsertions(op: newOp, listener);
592 auto walkFn = [&](Operation *walkedOp) {
593 listener->notifyOperationInserted(op: walkedOp, /*previous=*/{});
594 notifyBlockInsertions(op: walkedOp, listener);
595 };
596 for (Region &region : newOp->getRegions())
597 region.walk<WalkOrder::PreOrder>(callback&: walkFn);
598 }
599
600 return newOp;
601}
602
603Operation *OpBuilder::clone(Operation &op) {
604 IRMapping mapper;
605 return clone(op, mapper);
606}
607
608void OpBuilder::cloneRegionBefore(Region &region, Region &parent,
609 Region::iterator before, IRMapping &mapping) {
610 region.cloneInto(dest: &parent, destPos: before, mapper&: mapping);
611
612 // Fast path: If no listener is attached, there is no more work to do.
613 if (!listener)
614 return;
615
616 // Notify about op/block insertion.
617 for (auto it = mapping.lookup(from: &region.front())->getIterator(); it != before;
618 ++it) {
619 listener->notifyBlockInserted(block: &*it, /*previous=*/nullptr,
620 /*previousIt=*/{});
621 it->walk<WalkOrder::PreOrder>(callback: [&](Operation *walkedOp) {
622 listener->notifyOperationInserted(op: walkedOp, /*previous=*/{});
623 notifyBlockInsertions(op: walkedOp, listener);
624 });
625 }
626}
627
628void OpBuilder::cloneRegionBefore(Region &region, Region &parent,
629 Region::iterator before) {
630 IRMapping mapping;
631 cloneRegionBefore(region, parent, before, mapping);
632}
633
634void OpBuilder::cloneRegionBefore(Region &region, Block *before) {
635 cloneRegionBefore(region, parent&: *before->getParent(), before: before->getIterator());
636}
637