Skip to content

Commit ae11c5c

Browse files
kuharkuhar
authored
[mlir] Switch uses of deprecated .create methods to free function. NFC. (llvm#164635)
See https://discourse.llvm.org/t/psa-opty-create-now-with-100-more-tab-complete/87339.
1 parent f6ba213 commit ae11c5c

File tree

17 files changed

+110
-107
lines changed

17 files changed

+110
-107
lines changed

‎mlir/lib/Conversion/AMDGPUToROCDL/AMDGPUToROCDL.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1927,16 +1927,16 @@ struct AMDGPUPermlaneLowering : public ConvertOpToLLVMPattern<PermlaneSwapOp> {
19271927
else
19281928
llvm_unreachable("unsupported row length");
19291929

1930-
const Value vdst0 = LLVM::ExtractValueOp::create(rewriter, loc, res, {0});
1931-
const Value vdst1 = LLVM::ExtractValueOp::create(rewriter, loc, res, {1});
1930+
Value vdst0 = LLVM::ExtractValueOp::create(rewriter, loc, res, {0});
1931+
Value vdst1 = LLVM::ExtractValueOp::create(rewriter, loc, res, {1});
19321932

1933-
const Value isEqual =
1934-
rewriter.create<LLVM::ICmpOp>(loc, LLVM::ICmpPredicate::eq, vdst0, v);
1933+
Value isEqual = LLVM::ICmpOp::create(rewriter, loc,
1934+
LLVM::ICmpPredicate::eq, vdst0, v);
19351935

19361936
// Per `permlane(16|32)` semantics: if the first extracted element equals
19371937
// 'v', the result is the second element; otherwise it is the first.
19381938
Value vdstNew =
1939-
rewriter.create<LLVM::SelectOp>(loc, isEqual, vdst1, vdst0);
1939+
LLVM::SelectOp::create(rewriter, loc, isEqual, vdst1, vdst0);
19401940
permuted.emplace_back(vdstNew);
19411941
}
19421942

‎mlir/lib/Conversion/ComplexToROCDLLibraryCalls/ComplexToROCDLLibraryCalls.cpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -93,11 +93,11 @@ struct PowiOpToROCDLLibraryCalls : public OpRewritePattern<complex::PowiOp> {
9393

9494
Location loc = op.getLoc();
9595
Value exponentReal =
96-
rewriter.create<arith::SIToFPOp>(loc, exponentFloatType, op.getRhs());
97-
Value zeroImag = rewriter.create<arith::ConstantOp>(
98-
loc, rewriter.getZeroAttr(exponentFloatType));
99-
Value exponent = rewriter.create<complex::CreateOp>(
100-
loc, op.getLhs().getType(), exponentReal, zeroImag);
96+
arith::SIToFPOp::create(rewriter, loc, exponentFloatType, op.getRhs());
97+
Value zeroImag = arith::ConstantOp::create(
98+
rewriter, loc, rewriter.getZeroAttr(exponentFloatType));
99+
Value exponent = complex::CreateOp::create(
100+
rewriter, loc, op.getLhs().getType(), exponentReal, zeroImag);
101101

102102
rewriter.replaceOpWithNewOp<complex::PowOp>(op, op.getType(), op.getLhs(),
103103
exponent, op.getFastmathAttr());

‎mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -937,14 +937,14 @@ struct PowiOpConversion : public OpConversionPattern<complex::PowiOp> {
937937
auto elementType = cast<FloatType>(type.getElementType());
938938

939939
Value floatExponent =
940-
builder.create<arith::SIToFPOp>(elementType, adaptor.getRhs());
940+
arith::SIToFPOp::create(builder, elementType, adaptor.getRhs());
941941
Value zero = arith::ConstantOp::create(
942942
builder, elementType, builder.getFloatAttr(elementType, 0.0));
943943
Value complexExponent =
944944
complex::CreateOp::create(builder, type, floatExponent, zero);
945945

946-
auto pow = builder.create<complex::PowOp>(
947-
type, adaptor.getLhs(), complexExponent, op.getFastmathAttr());
946+
auto pow = complex::PowOp::create(builder, type, adaptor.getLhs(),
947+
complexExponent, op.getFastmathAttr());
948948
rewriter.replaceOp(op, pow.getResult());
949949
return success();
950950
}

‎mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -500,19 +500,19 @@ struct SincosOpLowering : public ConvertOpToLLVMPattern<math::SincosOp> {
500500
op->getParentWithTrait<mlir::OpTrait::AutomaticAllocationScope>();
501501
assert(scope && "Expected op to be inside automatic allocation scope");
502502
rewriter.setInsertionPointToStart(&scope->getRegion(0).front());
503-
auto one = rewriter.create<LLVM::ConstantOp>(
504-
loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(1));
503+
auto one = LLVM::ConstantOp::create(rewriter, loc, rewriter.getI32Type(),
504+
rewriter.getI32IntegerAttr(1));
505505
sinPtr =
506-
rewriter.create<LLVM::AllocaOp>(loc, ptrType, computeType, one, 0);
506+
LLVM::AllocaOp::create(rewriter, loc, ptrType, computeType, one, 0);
507507
cosPtr =
508-
rewriter.create<LLVM::AllocaOp>(loc, ptrType, computeType, one, 0);
508+
LLVM::AllocaOp::create(rewriter, loc, ptrType, computeType, one, 0);
509509
}
510510

511511
createSincosCall(rewriter, loc, sincosFunc, convertedInput, sinPtr, cosPtr,
512512
op);
513513

514-
auto sinResult = rewriter.create<LLVM::LoadOp>(loc, computeType, sinPtr);
515-
auto cosResult = rewriter.create<LLVM::LoadOp>(loc, computeType, cosPtr);
514+
auto sinResult = LLVM::LoadOp::create(rewriter, loc, computeType, sinPtr);
515+
auto cosResult = LLVM::LoadOp::create(rewriter, loc, computeType, cosPtr);
516516

517517
rewriter.replaceOp(op, {maybeTrunc(sinResult, inputType, rewriter),
518518
maybeTrunc(cosResult, inputType, rewriter)});
@@ -522,14 +522,15 @@ struct SincosOpLowering : public ConvertOpToLLVMPattern<math::SincosOp> {
522522
private:
523523
Value maybeExt(Value operand, PatternRewriter &rewriter) const {
524524
if (isa<Float16Type, BFloat16Type>(operand.getType()))
525-
return rewriter.create<LLVM::FPExtOp>(
526-
operand.getLoc(), Float32Type::get(rewriter.getContext()), operand);
525+
return LLVM::FPExtOp::create(rewriter, operand.getLoc(),
526+
Float32Type::get(rewriter.getContext()),
527+
operand);
527528
return operand;
528529
}
529530

530531
Value maybeTrunc(Value operand, Type type, PatternRewriter &rewriter) const {
531532
if (operand.getType() != type)
532-
return rewriter.create<LLVM::FPTruncOp>(operand.getLoc(), type, operand);
533+
return LLVM::FPTruncOp::create(rewriter, operand.getLoc(), type, operand);
533534
return operand;
534535
}
535536

@@ -556,7 +557,7 @@ struct SincosOpLowering : public ConvertOpToLLVMPattern<math::SincosOp> {
556557
}
557558

558559
SmallVector<Value> callOperands = {input, sinPtr, cosPtr};
559-
rewriter.create<LLVM::CallOp>(loc, funcOp, callOperands);
560+
LLVM::CallOp::create(rewriter, loc, funcOp, callOperands);
560561
}
561562
};
562563

‎mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -142,8 +142,8 @@ struct SincosOpLowering : public ConvertOpToLLVMPattern<math::SincosOp> {
142142
auto structType = LLVM::LLVMStructType::getLiteral(
143143
rewriter.getContext(), {llvmOperandType, llvmOperandType});
144144

145-
auto sincosOp = rewriter.create<LLVM::SincosOp>(
146-
loc, structType, adaptor.getOperand(), attrs.getAttrs());
145+
auto sincosOp = LLVM::SincosOp::create(
146+
rewriter, loc, structType, adaptor.getOperand(), attrs.getAttrs());
147147

148148
auto sinValue = LLVM::ExtractValueOp::create(rewriter, loc, sincosOp, 0);
149149
auto cosValue = LLVM::ExtractValueOp::create(rewriter, loc, sincosOp, 1);

‎mlir/lib/Conversion/SCFToEmitC/SCFToEmitC.cpp‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -394,9 +394,9 @@ struct WhileLowering : public OpConversionPattern<WhileOp> {
394394
if (!convertedType)
395395
return rewriter.notifyMatchFailure(whileOp, "type conversion failed");
396396

397-
emitc::VariableOp var = rewriter.create<emitc::VariableOp>(
398-
loc, emitc::LValueType::get(convertedType), noInit);
399-
rewriter.create<emitc::AssignOp>(loc, var.getResult(), init);
397+
auto var = emitc::VariableOp::create(
398+
rewriter, loc, emitc::LValueType::get(convertedType), noInit);
399+
emitc::AssignOp::create(rewriter, loc, var.getResult(), init);
400400
loopVars.push_back(var);
401401
}
402402

@@ -411,11 +411,11 @@ struct WhileLowering : public OpConversionPattern<WhileOp> {
411411
// Create a global boolean variable to store the loop condition state.
412412
Type i1Type = IntegerType::get(context, 1);
413413
auto globalCondition =
414-
rewriter.create<emitc::VariableOp>(loc, emitc::LValueType::get(i1Type),
415-
emitc::OpaqueAttr::get(context, ""));
414+
emitc::VariableOp::create(rewriter, loc, emitc::LValueType::get(i1Type),
415+
emitc::OpaqueAttr::get(context, ""));
416416
Value conditionVal = globalCondition.getResult();
417417

418-
auto loweredDo = rewriter.create<emitc::DoOp>(loc);
418+
auto loweredDo = emitc::DoOp::create(rewriter, loc);
419419

420420
// Convert region types to match the target dialect type system.
421421
if (failed(rewriter.convertRegionTypes(&whileOp.getBefore(),
@@ -450,12 +450,12 @@ struct WhileLowering : public OpConversionPattern<WhileOp> {
450450

451451
// Convert scf.condition to condition variable assignment.
452452
Value condition = rewriter.getRemappedValue(condOp.getCondition());
453-
rewriter.create<emitc::AssignOp>(loc, conditionVal, condition);
453+
emitc::AssignOp::create(rewriter, loc, conditionVal, condition);
454454

455455
// Wrap body region in conditional to preserve scf semantics. Only create
456456
// ifOp if after-region is non-empty.
457457
if (whileOp.getAfterBody()->getOperations().size() > 1) {
458-
auto ifOp = rewriter.create<emitc::IfOp>(loc, condition, false, false);
458+
auto ifOp = emitc::IfOp::create(rewriter, loc, condition, false, false);
459459

460460
// Prepare the after region (loop body) for merging.
461461
Block *afterBlock = &whileOp.getAfter().front();
@@ -480,8 +480,8 @@ struct WhileLowering : public OpConversionPattern<WhileOp> {
480480
Block *condBlock = rewriter.createBlock(&condRegion);
481481
rewriter.setInsertionPointToStart(condBlock);
482482

483-
auto exprOp = rewriter.create<emitc::ExpressionOp>(
484-
loc, i1Type, conditionVal, /*do_not_inline=*/false);
483+
auto exprOp = emitc::ExpressionOp::create(
484+
rewriter, loc, i1Type, conditionVal, /*do_not_inline=*/false);
485485
Block *exprBlock = rewriter.createBlock(&exprOp.getBodyRegion());
486486

487487
// Set up the expression block to load the condition variable.
@@ -490,12 +490,12 @@ struct WhileLowering : public OpConversionPattern<WhileOp> {
490490

491491
// Load the condition value and yield it as the expression result.
492492
Value cond =
493-
rewriter.create<emitc::LoadOp>(loc, i1Type, exprBlock->getArgument(0));
494-
rewriter.create<emitc::YieldOp>(loc, cond);
493+
emitc::LoadOp::create(rewriter, loc, i1Type, exprBlock->getArgument(0));
494+
emitc::YieldOp::create(rewriter, loc, cond);
495495

496496
// Yield the expression as the condition region result.
497497
rewriter.setInsertionPointToEnd(condBlock);
498-
rewriter.create<emitc::YieldOp>(loc, exprOp);
498+
emitc::YieldOp::create(rewriter, loc, exprOp);
499499

500500
return success();
501501
}

‎mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -232,16 +232,16 @@ static Value createLinalgBodyCalculationForElementwiseOp(
232232
}
233233

234234
intermediateType = rewriter.getIntegerType(intermediateBitWidth);
235-
zpAddValue = rewriter.create<arith::ConstantOp>(
236-
loc, rewriter.getIntegerAttr(intermediateType, zpAdd));
235+
zpAddValue = arith::ConstantOp::create(
236+
rewriter, loc, rewriter.getIntegerAttr(intermediateType, zpAdd));
237237
} else {
238238
intermediateType = rewriter.getIntegerType(intermediateBitWidth);
239239
auto arg1 =
240-
rewriter.create<arith::ExtSIOp>(loc, intermediateType, args[1]);
240+
arith::ExtSIOp::create(rewriter, loc, intermediateType, args[1]);
241241
auto arg2 =
242-
rewriter.create<arith::ExtSIOp>(loc, intermediateType, args[2]);
242+
arith::ExtSIOp::create(rewriter, loc, intermediateType, args[2]);
243243
zpAddValue =
244-
rewriter.create<arith::AddIOp>(loc, intermediateType, arg1, arg2);
244+
arith::AddIOp::create(rewriter, loc, intermediateType, arg1, arg2);
245245
}
246246

247247
// The negation can be applied by doing:
@@ -1402,8 +1402,8 @@ static Value collapse1xNTensorToN(PatternRewriter &rewriter, Value input,
14021402
auto elemType = inputType.getElementType();
14031403
auto collapsedType = RankedTensorType::get({}, elemType);
14041404
// Emit the collapse op
1405-
return rewriter.create<tensor::CollapseShapeOp>(loc, collapsedType, input,
1406-
reassociation);
1405+
return tensor::CollapseShapeOp::create(rewriter, loc, collapsedType, input,
1406+
reassociation);
14071407
}
14081408

14091409
static llvm::SmallVector<int8_t>
@@ -1443,7 +1443,7 @@ static void setupLinalgGenericOpInputAndIndexingMap(
14431443
IntegerAttr intAttr = isShift
14441444
? rewriter.getI8IntegerAttr(values.front())
14451445
: rewriter.getI32IntegerAttr(values.front());
1446-
constant = rewriter.create<arith::ConstantOp>(loc, intAttr);
1446+
constant = arith::ConstantOp::create(rewriter, loc, intAttr);
14471447
} else {
14481448
auto elementType =
14491449
isShift ? rewriter.getIntegerType(8) : rewriter.getI32Type();
@@ -1511,14 +1511,14 @@ static Value getExtendZp(OpBuilder &builder, Type valueTy,
15111511
.getResult(0);
15121512
}
15131513
if (zpTy.isUnsignedInteger()) {
1514-
return builder.create<arith::ExtUIOp>(loc, extendType, result);
1514+
return arith::ExtUIOp::create(builder, loc, extendType, result);
15151515
} else {
1516-
return builder.create<arith::ExtSIOp>(loc, extendType, result);
1516+
return arith::ExtSIOp::create(builder, loc, extendType, result);
15171517
}
15181518
}
15191519
} else {
1520-
return builder.create<arith::ConstantOp>(
1521-
loc, IntegerAttr::get(extendType, *maybeZp));
1520+
return arith::ConstantOp::create(builder, loc,
1521+
IntegerAttr::get(extendType, *maybeZp));
15221522
}
15231523
return result;
15241524
}

‎mlir/lib/Dialect/Linalg/TransformOps/LinalgTransformOps.cpp‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -437,13 +437,15 @@ transform::PromoteTensorOp::apply(transform::TransformRewriter &rewriter,
437437
for (auto [pos, dim] : llvm::enumerate(type.getShape())) {
438438
if (!ShapedType::isDynamic(dim))
439439
continue;
440-
Value cst = rewriter.create<arith::ConstantIndexOp>(tensor.getLoc(), pos);
441-
auto dimOp = rewriter.create<tensor::DimOp>(tensor.getLoc(), tensor, cst);
440+
Value cst =
441+
arith::ConstantIndexOp::create(rewriter, tensor.getLoc(), pos);
442+
auto dimOp =
443+
tensor::DimOp::create(rewriter, tensor.getLoc(), tensor, cst);
442444
preservedOps.insert(dimOp);
443445
dynamicDims.push_back(dimOp);
444446
}
445-
auto allocation = rewriter.create<bufferization::AllocTensorOp>(
446-
tensor.getLoc(), type, dynamicDims);
447+
auto allocation = bufferization::AllocTensorOp::create(
448+
rewriter, tensor.getLoc(), type, dynamicDims);
447449
// Set memory space if provided.
448450
if (getMemorySpaceAttr())
449451
allocation.setMemorySpaceAttr(getMemorySpaceAttr());
@@ -452,8 +454,8 @@ transform::PromoteTensorOp::apply(transform::TransformRewriter &rewriter,
452454
// Only insert a materialization (typically bufferizes to a copy) when the
453455
// value may be read from.
454456
if (needsMaterialization) {
455-
auto copy = rewriter.create<bufferization::MaterializeInDestinationOp>(
456-
tensor.getLoc(), tensor, allocated);
457+
auto copy = bufferization::MaterializeInDestinationOp::create(
458+
rewriter, tensor.getLoc(), tensor, allocated);
457459
preservedOps.insert(copy);
458460
promoted.push_back(copy.getResult());
459461
} else {

‎mlir/lib/Dialect/Linalg/Transforms/RuntimeOpVerification.cpp‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -50,24 +50,25 @@ struct StructuredOpInterface
5050
auto endValue = getValueOrCreateConstantIndexOp(builder, loc, end);
5151

5252
// Loop Trip count > 0 iff start < end
53-
Value dimensionHasNonZeroTripCount = builder.create<index::CmpOp>(
54-
loc, index::IndexCmpPredicate::SLT, startValue, endValue);
53+
Value dimensionHasNonZeroTripCount = index::CmpOp::create(
54+
builder, loc, index::IndexCmpPredicate::SLT, startValue, endValue);
5555

5656
if (!iterationDomainIsNonDegenerate) {
5757
iterationDomainIsNonDegenerate = dimensionHasNonZeroTripCount;
5858
} else {
5959
// Iteration domain is non-degenerate iff all dimensions have loop trip
6060
// count > 0
61-
iterationDomainIsNonDegenerate = builder.create<arith::AndIOp>(
62-
loc, iterationDomainIsNonDegenerate, dimensionHasNonZeroTripCount);
61+
iterationDomainIsNonDegenerate =
62+
arith::AndIOp::create(builder, loc, iterationDomainIsNonDegenerate,
63+
dimensionHasNonZeroTripCount);
6364
}
6465
}
6566

6667
if (!iterationDomainIsNonDegenerate)
6768
return;
6869

69-
auto ifOp = builder.create<scf::IfOp>(loc, iterationDomainIsNonDegenerate,
70-
/*withElseRegion=*/false);
70+
auto ifOp = scf::IfOp::create(builder, loc, iterationDomainIsNonDegenerate,
71+
/*withElseRegion=*/false);
7172
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
7273

7374
// Subtract one from the loop ends before composing with the indexing map

‎mlir/lib/Dialect/SCF/IR/SCF.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2490,8 +2490,8 @@ struct ConditionPropagation : public OpRewritePattern<IfOp> {
24902490
changed = true;
24912491

24922492
if (!constantTrue)
2493-
constantTrue = rewriter.create<arith::ConstantOp>(
2494-
op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 1));
2493+
constantTrue = arith::ConstantOp::create(
2494+
rewriter, op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 1));
24952495

24962496
rewriter.modifyOpInPlace(use.getOwner(),
24972497
[&]() { use.set(constantTrue); });
@@ -2500,8 +2500,8 @@ struct ConditionPropagation : public OpRewritePattern<IfOp> {
25002500
changed = true;
25012501

25022502
if (!constantFalse)
2503-
constantFalse = rewriter.create<arith::ConstantOp>(
2504-
op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 0));
2503+
constantFalse = arith::ConstantOp::create(
2504+
rewriter, op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 0));
25052505

25062506
rewriter.modifyOpInPlace(use.getOwner(),
25072507
[&]() { use.set(constantFalse); });

0 commit comments

Comments
 (0)