Skip to content

Commit 38976a0

Browse files
authored
[mlir][NFC] update Conversion create APIs (7/n) (#149889)
See #147168 for more info.
1 parent c37942d commit 38976a0

File tree

23 files changed

+1656
-1595
lines changed

23 files changed

+1656
-1595
lines changed

mlir/lib/Conversion/SCFToControlFlow/SCFToControlFlow.cpp

Lines changed: 29 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -340,15 +340,15 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp,
340340
Operation *terminator = lastBodyBlock->getTerminator();
341341
rewriter.setInsertionPointToEnd(lastBodyBlock);
342342
auto step = forOp.getStep();
343-
auto stepped = rewriter.create<arith::AddIOp>(loc, iv, step).getResult();
343+
auto stepped = arith::AddIOp::create(rewriter, loc, iv, step).getResult();
344344
if (!stepped)
345345
return failure();
346346

347347
SmallVector<Value, 8> loopCarried;
348348
loopCarried.push_back(stepped);
349349
loopCarried.append(terminator->operand_begin(), terminator->operand_end());
350350
auto branchOp =
351-
rewriter.create<cf::BranchOp>(loc, conditionBlock, loopCarried);
351+
cf::BranchOp::create(rewriter, loc, conditionBlock, loopCarried);
352352

353353
// Let the CondBranchOp carry the LLVM attributes from the ForOp, such as the
354354
// llvm.loop_annotation attribute.
@@ -375,16 +375,15 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp,
375375
SmallVector<Value, 8> destOperands;
376376
destOperands.push_back(lowerBound);
377377
llvm::append_range(destOperands, forOp.getInitArgs());
378-
rewriter.create<cf::BranchOp>(loc, conditionBlock, destOperands);
378+
cf::BranchOp::create(rewriter, loc, conditionBlock, destOperands);
379379

380380
// With the body block done, we can fill in the condition block.
381381
rewriter.setInsertionPointToEnd(conditionBlock);
382-
auto comparison = rewriter.create<arith::CmpIOp>(
383-
loc, arith::CmpIPredicate::slt, iv, upperBound);
382+
auto comparison = arith::CmpIOp::create(
383+
rewriter, loc, arith::CmpIPredicate::slt, iv, upperBound);
384384

385-
rewriter.create<cf::CondBranchOp>(loc, comparison, firstBodyBlock,
386-
ArrayRef<Value>(), endBlock,
387-
ArrayRef<Value>());
385+
cf::CondBranchOp::create(rewriter, loc, comparison, firstBodyBlock,
386+
ArrayRef<Value>(), endBlock, ArrayRef<Value>());
388387

389388
// The result of the loop operation is the values of the condition block
390389
// arguments except the induction variable on the last iteration.
@@ -409,7 +408,7 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
409408
continueBlock =
410409
rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes(),
411410
SmallVector<Location>(ifOp.getNumResults(), loc));
412-
rewriter.create<cf::BranchOp>(loc, remainingOpsBlock);
411+
cf::BranchOp::create(rewriter, loc, remainingOpsBlock);
413412
}
414413

415414
// Move blocks from the "then" region to the region containing 'scf.if',
@@ -419,7 +418,7 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
419418
Operation *thenTerminator = thenRegion.back().getTerminator();
420419
ValueRange thenTerminatorOperands = thenTerminator->getOperands();
421420
rewriter.setInsertionPointToEnd(&thenRegion.back());
422-
rewriter.create<cf::BranchOp>(loc, continueBlock, thenTerminatorOperands);
421+
cf::BranchOp::create(rewriter, loc, continueBlock, thenTerminatorOperands);
423422
rewriter.eraseOp(thenTerminator);
424423
rewriter.inlineRegionBefore(thenRegion, continueBlock);
425424

@@ -433,15 +432,15 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
433432
Operation *elseTerminator = elseRegion.back().getTerminator();
434433
ValueRange elseTerminatorOperands = elseTerminator->getOperands();
435434
rewriter.setInsertionPointToEnd(&elseRegion.back());
436-
rewriter.create<cf::BranchOp>(loc, continueBlock, elseTerminatorOperands);
435+
cf::BranchOp::create(rewriter, loc, continueBlock, elseTerminatorOperands);
437436
rewriter.eraseOp(elseTerminator);
438437
rewriter.inlineRegionBefore(elseRegion, continueBlock);
439438
}
440439

441440
rewriter.setInsertionPointToEnd(condBlock);
442-
rewriter.create<cf::CondBranchOp>(loc, ifOp.getCondition(), thenBlock,
443-
/*trueArgs=*/ArrayRef<Value>(), elseBlock,
444-
/*falseArgs=*/ArrayRef<Value>());
441+
cf::CondBranchOp::create(rewriter, loc, ifOp.getCondition(), thenBlock,
442+
/*trueArgs=*/ArrayRef<Value>(), elseBlock,
443+
/*falseArgs=*/ArrayRef<Value>());
445444

446445
// Ok, we're done!
447446
rewriter.replaceOp(ifOp, continueBlock->getArguments());
@@ -459,13 +458,14 @@ ExecuteRegionLowering::matchAndRewrite(ExecuteRegionOp op,
459458

460459
auto &region = op.getRegion();
461460
rewriter.setInsertionPointToEnd(condBlock);
462-
rewriter.create<cf::BranchOp>(loc, &region.front());
461+
cf::BranchOp::create(rewriter, loc, &region.front());
463462

464463
for (Block &block : region) {
465464
if (auto terminator = dyn_cast<scf::YieldOp>(block.getTerminator())) {
466465
ValueRange terminatorOperands = terminator->getOperands();
467466
rewriter.setInsertionPointToEnd(&block);
468-
rewriter.create<cf::BranchOp>(loc, remainingOpsBlock, terminatorOperands);
467+
cf::BranchOp::create(rewriter, loc, remainingOpsBlock,
468+
terminatorOperands);
469469
rewriter.eraseOp(terminator);
470470
}
471471
}
@@ -503,7 +503,7 @@ ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
503503
for (auto [iv, lower, upper, step] :
504504
llvm::zip(parallelOp.getInductionVars(), parallelOp.getLowerBound(),
505505
parallelOp.getUpperBound(), parallelOp.getStep())) {
506-
ForOp forOp = rewriter.create<ForOp>(loc, lower, upper, step, iterArgs);
506+
ForOp forOp = ForOp::create(rewriter, loc, lower, upper, step, iterArgs);
507507
ivs.push_back(forOp.getInductionVar());
508508
auto iterRange = forOp.getRegionIterArgs();
509509
iterArgs.assign(iterRange.begin(), iterRange.end());
@@ -517,7 +517,7 @@ ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
517517
// A loop is constructed with an empty "yield" terminator if there are
518518
// no results.
519519
rewriter.setInsertionPointToEnd(rewriter.getInsertionBlock());
520-
rewriter.create<scf::YieldOp>(loc, forOp.getResults());
520+
scf::YieldOp::create(rewriter, loc, forOp.getResults());
521521
}
522522

523523
rewriter.setInsertionPointToStart(forOp.getBody());
@@ -549,7 +549,7 @@ ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
549549
// has been already created in loop construction).
550550
if (!yieldOperands.empty()) {
551551
rewriter.setInsertionPointToEnd(rewriter.getInsertionBlock());
552-
rewriter.create<scf::YieldOp>(loc, yieldOperands);
552+
scf::YieldOp::create(rewriter, loc, yieldOperands);
553553
}
554554

555555
rewriter.replaceOp(parallelOp, loopResults);
@@ -575,7 +575,7 @@ LogicalResult WhileLowering::matchAndRewrite(WhileOp whileOp,
575575

576576
// Branch to the "before" region.
577577
rewriter.setInsertionPointToEnd(currentBlock);
578-
rewriter.create<cf::BranchOp>(loc, before, whileOp.getInits());
578+
cf::BranchOp::create(rewriter, loc, before, whileOp.getInits());
579579

580580
// Replace terminators with branches. Assuming bodies are SESE, which holds
581581
// given only the patterns from this file, we only need to look at the last
@@ -625,14 +625,14 @@ DoWhileLowering::matchAndRewrite(WhileOp whileOp,
625625

626626
// Branch to the "before" region.
627627
rewriter.setInsertionPointToEnd(currentBlock);
628-
rewriter.create<cf::BranchOp>(whileOp.getLoc(), before, whileOp.getInits());
628+
cf::BranchOp::create(rewriter, whileOp.getLoc(), before, whileOp.getInits());
629629

630630
// Loop around the "before" region based on condition.
631631
rewriter.setInsertionPointToEnd(before);
632632
auto condOp = cast<ConditionOp>(before->getTerminator());
633-
rewriter.create<cf::CondBranchOp>(condOp.getLoc(), condOp.getCondition(),
634-
before, condOp.getArgs(), continuation,
635-
ValueRange());
633+
cf::CondBranchOp::create(rewriter, condOp.getLoc(), condOp.getCondition(),
634+
before, condOp.getArgs(), continuation,
635+
ValueRange());
636636

637637
// Replace the op with values "yielded" from the "before" region, which are
638638
// visible by dominance.
@@ -695,12 +695,12 @@ IndexSwitchLowering::matchAndRewrite(IndexSwitchOp op,
695695
SmallVector<ValueRange> caseOperands(caseSuccessors.size(), {});
696696

697697
// Cast switch index to integer case value.
698-
Value caseValue = rewriter.create<arith::IndexCastOp>(
699-
op.getLoc(), rewriter.getI32Type(), op.getArg());
698+
Value caseValue = arith::IndexCastOp::create(
699+
rewriter, op.getLoc(), rewriter.getI32Type(), op.getArg());
700700

701-
rewriter.create<cf::SwitchOp>(
702-
op.getLoc(), caseValue, *defaultBlock, ValueRange(),
703-
rewriter.getDenseI32ArrayAttr(caseValues), caseSuccessors, caseOperands);
701+
cf::SwitchOp::create(rewriter, op.getLoc(), caseValue, *defaultBlock,
702+
ValueRange(), rewriter.getDenseI32ArrayAttr(caseValues),
703+
caseSuccessors, caseOperands);
704704
rewriter.replaceOp(op, continueBlock->getArguments());
705705
return success();
706706
}

mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ createVariablesForResults(T op, const TypeConverter *typeConverter,
9191
Type varType = emitc::LValueType::get(resultType);
9292
emitc::OpaqueAttr noInit = emitc::OpaqueAttr::get(context, "");
9393
emitc::VariableOp var =
94-
rewriter.create<emitc::VariableOp>(loc, varType, noInit);
94+
emitc::VariableOp::create(rewriter, loc, varType, noInit);
9595
resultVariables.push_back(var);
9696
}
9797

@@ -103,14 +103,14 @@ createVariablesForResults(T op, const TypeConverter *typeConverter,
103103
static void assignValues(ValueRange values, ValueRange variables,
104104
ConversionPatternRewriter &rewriter, Location loc) {
105105
for (auto [value, var] : llvm::zip(values, variables))
106-
rewriter.create<emitc::AssignOp>(loc, var, value);
106+
emitc::AssignOp::create(rewriter, loc, var, value);
107107
}
108108

109109
SmallVector<Value> loadValues(const SmallVector<Value> &variables,
110110
PatternRewriter &rewriter, Location loc) {
111111
return llvm::map_to_vector<>(variables, [&](Value var) {
112112
Type type = cast<emitc::LValueType>(var.getType()).getValueType();
113-
return rewriter.create<emitc::LoadOp>(loc, type, var).getResult();
113+
return emitc::LoadOp::create(rewriter, loc, type, var).getResult();
114114
});
115115
}
116116

@@ -129,7 +129,7 @@ static LogicalResult lowerYield(Operation *op, ValueRange resultVariables,
129129

130130
assignValues(yieldOperands, resultVariables, rewriter, loc);
131131

132-
rewriter.create<emitc::YieldOp>(loc);
132+
emitc::YieldOp::create(rewriter, loc);
133133
rewriter.eraseOp(yield);
134134

135135
return success();
@@ -164,8 +164,9 @@ ForLowering::matchAndRewrite(ForOp forOp, OpAdaptor adaptor,
164164

165165
assignValues(adaptor.getInitArgs(), resultVariables, rewriter, loc);
166166

167-
emitc::ForOp loweredFor = rewriter.create<emitc::ForOp>(
168-
loc, adaptor.getLowerBound(), adaptor.getUpperBound(), adaptor.getStep());
167+
emitc::ForOp loweredFor =
168+
emitc::ForOp::create(rewriter, loc, adaptor.getLowerBound(),
169+
adaptor.getUpperBound(), adaptor.getStep());
169170

170171
Block *loweredBody = loweredFor.getBody();
171172

@@ -257,7 +258,7 @@ IfLowering::matchAndRewrite(IfOp ifOp, OpAdaptor adaptor,
257258
bool hasElseBlock = !elseRegion.empty();
258259

259260
auto loweredIf =
260-
rewriter.create<emitc::IfOp>(loc, adaptor.getCondition(), false, false);
261+
emitc::IfOp::create(rewriter, loc, adaptor.getCondition(), false, false);
261262

262263
Region &loweredThenRegion = loweredIf.getThenRegion();
263264
auto result = lowerRegion(thenRegion, loweredThenRegion);
@@ -304,8 +305,9 @@ LogicalResult IndexSwitchOpLowering::matchAndRewrite(
304305
"create variables for results failed");
305306
}
306307

307-
auto loweredSwitch = rewriter.create<emitc::SwitchOp>(
308-
loc, adaptor.getArg(), adaptor.getCases(), indexSwitchOp.getNumCases());
308+
auto loweredSwitch =
309+
emitc::SwitchOp::create(rewriter, loc, adaptor.getArg(),
310+
adaptor.getCases(), indexSwitchOp.getNumCases());
309311

310312
// Lowering all case regions.
311313
for (auto pair :

0 commit comments

Comments
 (0)