[Mlir-commits] [mlir] [mlir][NFC] update `mlir/lib` create APIs (26/n) (PR #149933)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Mon Jul 21 15:47:58 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir-spirv
@llvm/pr-subscribers-mlir-llvm
Author: Maksim Levental (makslevental)
<details>
<summary>Changes</summary>
See https://github.com/llvm/llvm-project/pull/147168 for more info.
---
Patch is 46.10 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/149933.diff
8 Files Affected:
- (modified) mlir/lib/IR/BuiltinDialect.cpp (+1-1)
- (modified) mlir/lib/Query/Query.cpp (+1-1)
- (modified) mlir/lib/Target/LLVMIR/LLVMImportInterface.cpp (+2-2)
- (modified) mlir/lib/Target/LLVMIR/ModuleImport.cpp (+71-70)
- (modified) mlir/lib/Target/SPIRV/Deserialization/DeserializeOps.cpp (+27-23)
- (modified) mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp (+34-34)
- (modified) mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp (+39-38)
- (modified) mlir/lib/Transforms/Utils/DialectConversion.cpp (+1-1)
``````````diff
diff --git a/mlir/lib/IR/BuiltinDialect.cpp b/mlir/lib/IR/BuiltinDialect.cpp
index 6d7e2aa0ece7d..c88b328282275 100644
--- a/mlir/lib/IR/BuiltinDialect.cpp
+++ b/mlir/lib/IR/BuiltinDialect.cpp
@@ -132,7 +132,7 @@ void ModuleOp::build(OpBuilder &builder, OperationState &state,
/// Construct a module from the given context.
ModuleOp ModuleOp::create(Location loc, std::optional<StringRef> name) {
OpBuilder builder(loc->getContext());
- return builder.create<ModuleOp>(loc, name);
+ return ModuleOp::create(builder, loc, name);
}
DataLayoutSpecInterface ModuleOp::getDataLayoutSpec() {
diff --git a/mlir/lib/Query/Query.cpp b/mlir/lib/Query/Query.cpp
index b5a9d2f1d350c..03e4177bbbe24 100644
--- a/mlir/lib/Query/Query.cpp
+++ b/mlir/lib/Query/Query.cpp
@@ -77,7 +77,7 @@ static Operation *extractFunction(std::vector<Operation *> &ops,
clonedOp->result_end());
}
// Add return operation
- builder.create<func::ReturnOp>(loc, clonedVals);
+ func::ReturnOp::create(builder, loc, clonedVals);
// Remove unused function arguments
size_t currentIndex = 0;
diff --git a/mlir/lib/Target/LLVMIR/LLVMImportInterface.cpp b/mlir/lib/Target/LLVMIR/LLVMImportInterface.cpp
index 4e7f1d3185129..0fb1adbbf75aa 100644
--- a/mlir/lib/Target/LLVMIR/LLVMImportInterface.cpp
+++ b/mlir/lib/Target/LLVMIR/LLVMImportInterface.cpp
@@ -37,8 +37,8 @@ LogicalResult mlir::LLVMImportInterface::convertUnregisteredIntrinsic(
return failure();
Type resultType = moduleImport.convertType(inst->getType());
- auto op = builder.create<::mlir::LLVM::CallIntrinsicOp>(
- moduleImport.translateLoc(inst->getDebugLoc()),
+ auto op = ::mlir::LLVM::CallIntrinsicOp::create(
+ builder, moduleImport.translateLoc(inst->getDebugLoc()),
isa<LLVMVoidType>(resultType) ? TypeRange{} : TypeRange{resultType},
StringAttr::get(builder.getContext(), intrinName),
ValueRange{mlirOperands}, FastmathFlagsAttr{});
diff --git a/mlir/lib/Target/LLVMIR/ModuleImport.cpp b/mlir/lib/Target/LLVMIR/ModuleImport.cpp
index c807985756539..94db7f8888129 100644
--- a/mlir/lib/Target/LLVMIR/ModuleImport.cpp
+++ b/mlir/lib/Target/LLVMIR/ModuleImport.cpp
@@ -185,7 +185,7 @@ ComdatOp ModuleImport::getGlobalComdatOp() {
OpBuilder::InsertionGuard guard(builder);
builder.setInsertionPointToEnd(mlirModule.getBody());
globalComdatOp =
- builder.create<ComdatOp>(mlirModule.getLoc(), getGlobalComdatOpName());
+ ComdatOp::create(builder, mlirModule.getLoc(), getGlobalComdatOpName());
globalInsertionOp = globalComdatOp;
return globalComdatOp;
}
@@ -864,8 +864,8 @@ LogicalResult ModuleImport::convertModuleFlagsMetadata() {
}
if (!moduleFlags.empty())
- builder.create<LLVM::ModuleFlagsOp>(mlirModule.getLoc(),
- builder.getArrayAttr(moduleFlags));
+ LLVM::ModuleFlagsOp::create(builder, mlirModule.getLoc(),
+ builder.getArrayAttr(moduleFlags));
return success();
}
@@ -880,8 +880,8 @@ LogicalResult ModuleImport::convertLinkerOptionsMetadata() {
options.reserve(node->getNumOperands());
for (const llvm::MDOperand &option : node->operands())
options.push_back(cast<llvm::MDString>(option)->getString());
- builder.create<LLVM::LinkerOptionsOp>(mlirModule.getLoc(),
- builder.getStrArrayAttr(options));
+ LLVM::LinkerOptionsOp::create(builder, mlirModule.getLoc(),
+ builder.getStrArrayAttr(options));
}
}
return success();
@@ -984,8 +984,8 @@ void ModuleImport::processComdat(const llvm::Comdat *comdat) {
ComdatOp comdatOp = getGlobalComdatOp();
OpBuilder::InsertionGuard guard(builder);
builder.setInsertionPointToEnd(&comdatOp.getBody().back());
- auto selectorOp = builder.create<ComdatSelectorOp>(
- mlirModule.getLoc(), comdat->getName(),
+ auto selectorOp = ComdatSelectorOp::create(
+ builder, mlirModule.getLoc(), comdat->getName(),
convertComdatFromLLVM(comdat->getSelectionKind()));
auto symbolRef =
SymbolRefAttr::get(builder.getContext(), getGlobalComdatOpName(),
@@ -1356,12 +1356,12 @@ LogicalResult ModuleImport::convertAlias(llvm::GlobalAlias *alias) {
OpBuilder::InsertionGuard guard = setGlobalInsertionPoint();
Type type = convertType(alias->getValueType());
- AliasOp aliasOp = builder.create<AliasOp>(
- mlirModule.getLoc(), type, convertLinkageFromLLVM(alias->getLinkage()),
- alias->getName(),
- /*dso_local=*/alias->isDSOLocal(),
- /*thread_local=*/alias->isThreadLocal(),
- /*attrs=*/ArrayRef<NamedAttribute>());
+ AliasOp aliasOp = AliasOp::create(builder, mlirModule.getLoc(), type,
+ convertLinkageFromLLVM(alias->getLinkage()),
+ alias->getName(),
+ /*dso_local=*/alias->isDSOLocal(),
+ /*thread_local=*/alias->isThreadLocal(),
+ /*attrs=*/ArrayRef<NamedAttribute>());
globalInsertionOp = aliasOp;
clearRegionState();
@@ -1370,7 +1370,7 @@ LogicalResult ModuleImport::convertAlias(llvm::GlobalAlias *alias) {
FailureOr<Value> initializer = convertConstantExpr(alias->getAliasee());
if (failed(initializer))
return failure();
- builder.create<ReturnOp>(aliasOp.getLoc(), *initializer);
+ ReturnOp::create(builder, aliasOp.getLoc(), *initializer);
if (alias->hasAtLeastLocalUnnamedAddr())
aliasOp.setUnnamedAddr(convertUnnamedAddrFromLLVM(alias->getUnnamedAddr()));
@@ -1385,12 +1385,12 @@ LogicalResult ModuleImport::convertIFunc(llvm::GlobalIFunc *ifunc) {
Type type = convertType(ifunc->getValueType());
llvm::Constant *resolver = ifunc->getResolver();
Type resolverType = convertType(resolver->getType());
- builder.create<IFuncOp>(mlirModule.getLoc(), ifunc->getName(), type,
- resolver->getName(), resolverType,
- convertLinkageFromLLVM(ifunc->getLinkage()),
- ifunc->isDSOLocal(), ifunc->getAddressSpace(),
- convertUnnamedAddrFromLLVM(ifunc->getUnnamedAddr()),
- convertVisibilityFromLLVM(ifunc->getVisibility()));
+ IFuncOp::create(builder, mlirModule.getLoc(), ifunc->getName(), type,
+ resolver->getName(), resolverType,
+ convertLinkageFromLLVM(ifunc->getLinkage()),
+ ifunc->isDSOLocal(), ifunc->getAddressSpace(),
+ convertUnnamedAddrFromLLVM(ifunc->getUnnamedAddr()),
+ convertVisibilityFromLLVM(ifunc->getVisibility()));
return success();
}
@@ -1428,8 +1428,8 @@ LogicalResult ModuleImport::convertGlobal(llvm::GlobalVariable *globalVar) {
if (globalName.empty())
globalName = getOrCreateNamelessSymbolName(globalVar).getValue();
- GlobalOp globalOp = builder.create<GlobalOp>(
- mlirModule.getLoc(), type, globalVar->isConstant(),
+ GlobalOp globalOp = GlobalOp::create(
+ builder, mlirModule.getLoc(), type, globalVar->isConstant(),
convertLinkageFromLLVM(globalVar->getLinkage()), StringRef(globalName),
valueAttr, alignment, /*addr_space=*/globalVar->getAddressSpace(),
/*dso_local=*/globalVar->isDSOLocal(),
@@ -1445,7 +1445,7 @@ LogicalResult ModuleImport::convertGlobal(llvm::GlobalVariable *globalVar) {
convertConstantExpr(globalVar->getInitializer());
if (failed(initializer))
return failure();
- builder.create<ReturnOp>(globalOp.getLoc(), *initializer);
+ ReturnOp::create(builder, globalOp.getLoc(), *initializer);
}
if (globalVar->hasAtLeastLocalUnnamedAddr()) {
globalOp.setUnnamedAddr(
@@ -1513,13 +1513,13 @@ ModuleImport::convertGlobalCtorsAndDtors(llvm::GlobalVariable *globalVar) {
OpBuilder::InsertionGuard guard = setGlobalInsertionPoint();
if (globalVar->getName() == getGlobalCtorsVarName()) {
- globalInsertionOp = builder.create<LLVM::GlobalCtorsOp>(
- mlirModule.getLoc(), builder.getArrayAttr(funcs),
+ globalInsertionOp = LLVM::GlobalCtorsOp::create(
+ builder, mlirModule.getLoc(), builder.getArrayAttr(funcs),
builder.getI32ArrayAttr(priorities), builder.getArrayAttr(dataList));
return success();
}
- globalInsertionOp = builder.create<LLVM::GlobalDtorsOp>(
- mlirModule.getLoc(), builder.getArrayAttr(funcs),
+ globalInsertionOp = LLVM::GlobalDtorsOp::create(
+ builder, mlirModule.getLoc(), builder.getArrayAttr(funcs),
builder.getI32ArrayAttr(priorities), builder.getArrayAttr(dataList));
return success();
}
@@ -1594,33 +1594,33 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
if (Attribute attr = getConstantAsAttr(constant)) {
Type type = convertType(constant->getType());
if (auto symbolRef = dyn_cast<FlatSymbolRefAttr>(attr)) {
- return builder.create<AddressOfOp>(loc, type, symbolRef.getValue())
+ return AddressOfOp::create(builder, loc, type, symbolRef.getValue())
.getResult();
}
- return builder.create<ConstantOp>(loc, type, attr).getResult();
+ return ConstantOp::create(builder, loc, type, attr).getResult();
}
// Convert null pointer constants.
if (auto *nullPtr = dyn_cast<llvm::ConstantPointerNull>(constant)) {
Type type = convertType(nullPtr->getType());
- return builder.create<ZeroOp>(loc, type).getResult();
+ return ZeroOp::create(builder, loc, type).getResult();
}
// Convert none token constants.
if (isa<llvm::ConstantTokenNone>(constant)) {
- return builder.create<NoneTokenOp>(loc).getResult();
+ return NoneTokenOp::create(builder, loc).getResult();
}
// Convert poison.
if (auto *poisonVal = dyn_cast<llvm::PoisonValue>(constant)) {
Type type = convertType(poisonVal->getType());
- return builder.create<PoisonOp>(loc, type).getResult();
+ return PoisonOp::create(builder, loc, type).getResult();
}
// Convert undef.
if (auto *undefVal = dyn_cast<llvm::UndefValue>(constant)) {
Type type = convertType(undefVal->getType());
- return builder.create<UndefOp>(loc, type).getResult();
+ return UndefOp::create(builder, loc, type).getResult();
}
// Convert dso_local_equivalent.
@@ -1646,7 +1646,7 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
getOrCreateNamelessSymbolName(cast<llvm::GlobalVariable>(globalObj));
else
symbolRef = FlatSymbolRefAttr::get(context, globalName);
- return builder.create<AddressOfOp>(loc, type, symbolRef).getResult();
+ return AddressOfOp::create(builder, loc, type, symbolRef).getResult();
}
// Convert global alias accesses.
@@ -1654,7 +1654,7 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
Type type = convertType(globalAliasObj->getType());
StringRef aliaseeName = globalAliasObj->getName();
FlatSymbolRefAttr symbolRef = FlatSymbolRefAttr::get(context, aliaseeName);
- return builder.create<AddressOfOp>(loc, type, symbolRef).getResult();
+ return AddressOfOp::create(builder, loc, type, symbolRef).getResult();
}
// Convert constant expressions.
@@ -1705,16 +1705,17 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
bool isArrayOrStruct = isa<LLVMArrayType, LLVMStructType>(rootType);
assert((isArrayOrStruct || LLVM::isCompatibleVectorType(rootType)) &&
"unrecognized aggregate type");
- Value root = builder.create<UndefOp>(loc, rootType);
+ Value root = UndefOp::create(builder, loc, rootType);
for (const auto &it : llvm::enumerate(elementValues)) {
if (isArrayOrStruct) {
- root = builder.create<InsertValueOp>(loc, root, it.value(), it.index());
+ root =
+ InsertValueOp::create(builder, loc, root, it.value(), it.index());
} else {
Attribute indexAttr = builder.getI32IntegerAttr(it.index());
Value indexValue =
- builder.create<ConstantOp>(loc, builder.getI32Type(), indexAttr);
- root = builder.create<InsertElementOp>(loc, rootType, root, it.value(),
- indexValue);
+ ConstantOp::create(builder, loc, builder.getI32Type(), indexAttr);
+ root = InsertElementOp::create(builder, loc, rootType, root, it.value(),
+ indexValue);
}
}
return root;
@@ -1727,7 +1728,7 @@ FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
"target extension type does not support zero-initialization");
// Create llvm.mlir.zero operation to represent zero-initialization of
// target extension type.
- return builder.create<LLVM::ZeroOp>(loc, targetExtType).getRes();
+ return LLVM::ZeroOp::create(builder, loc, targetExtType).getRes();
}
if (auto *blockAddr = dyn_cast<llvm::BlockAddress>(constant)) {
@@ -2158,16 +2159,16 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
}
if (!brInst->isConditional()) {
- auto brOp = builder.create<LLVM::BrOp>(loc, succBlockArgs.front(),
- succBlocks.front());
+ auto brOp = LLVM::BrOp::create(builder, loc, succBlockArgs.front(),
+ succBlocks.front());
mapNoResultOp(inst, brOp);
return success();
}
FailureOr<Value> condition = convertValue(brInst->getCondition());
if (failed(condition))
return failure();
- auto condBrOp = builder.create<LLVM::CondBrOp>(
- loc, *condition, succBlocks.front(), succBlockArgs.front(),
+ auto condBrOp = LLVM::CondBrOp::create(
+ builder, loc, *condition, succBlocks.front(), succBlockArgs.front(),
succBlocks.back(), succBlockArgs.back());
mapNoResultOp(inst, condBrOp);
return success();
@@ -2200,9 +2201,9 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
caseBlocks[it.index()] = lookupBlock(succBB);
}
- auto switchOp = builder.create<SwitchOp>(
- loc, *condition, lookupBlock(defaultBB), defaultBlockArgs, caseValues,
- caseBlocks, caseOperandRefs);
+ auto switchOp = SwitchOp::create(builder, loc, *condition,
+ lookupBlock(defaultBB), defaultBlockArgs,
+ caseValues, caseBlocks, caseOperandRefs);
mapNoResultOp(inst, switchOp);
return success();
}
@@ -2252,14 +2253,14 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
// IR). Build the indirect call by passing an empty `callee` operand and
// insert into `operands` to include the indirect call target.
FlatSymbolRefAttr calleeSym = convertCalleeName(callInst);
- Value indirectCallVal = builder.create<LLVM::AddressOfOp>(
- loc, LLVM::LLVMPointerType::get(context), calleeSym);
+ Value indirectCallVal = LLVM::AddressOfOp::create(
+ builder, loc, LLVM::LLVMPointerType::get(context), calleeSym);
operands->insert(operands->begin(), indirectCallVal);
} else {
// Regular direct call using callee name.
callee = convertCalleeName(callInst);
}
- CallOp callOp = builder.create<CallOp>(loc, *funcTy, callee, *operands);
+ CallOp callOp = CallOp::create(builder, loc, *funcTy, callee, *operands);
if (failed(convertCallAttributes(callInst, callOp)))
return failure();
@@ -2294,7 +2295,7 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
Type type = convertType(lpInst->getType());
auto lpOp =
- builder.create<LandingpadOp>(loc, type, lpInst->isCleanup(), operands);
+ LandingpadOp::create(builder, loc, type, lpInst->isCleanup(), operands);
mapValue(inst, lpOp);
return success();
}
@@ -2344,8 +2345,8 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
// IR). Build the indirect invoke by passing an empty `callee` operand and
// insert into `operands` to include the indirect invoke target.
FlatSymbolRefAttr calleeSym = convertCalleeName(invokeInst);
- Value indirectInvokeVal = builder.create<LLVM::AddressOfOp>(
- loc, LLVM::LLVMPointerType::get(context), calleeSym);
+ Value indirectInvokeVal = LLVM::AddressOfOp::create(
+ builder, loc, LLVM::LLVMPointerType::get(context), calleeSym);
operands->insert(operands->begin(), indirectInvokeVal);
} else {
// Regular direct invoke using callee name.
@@ -2354,9 +2355,9 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
// Create the invoke operation. Normal destination block arguments will be
// added later on to handle the case in which the operation result is
// included in this list.
- auto invokeOp = builder.create<InvokeOp>(
- loc, *funcTy, calleeName, *operands, directNormalDest, ValueRange(),
- lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
+ auto invokeOp = InvokeOp::create(
+ builder, loc, *funcTy, calleeName, *operands, directNormalDest,
+ ValueRange(), lookupBlock(invokeInst->getUnwindDest()), unwindArgs);
if (failed(convertInvokeAttributes(invokeInst, invokeOp)))
return failure();
@@ -2382,7 +2383,7 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
// arguments (including the invoke operation's result).
OpBuilder::InsertionGuard g(builder);
builder.setInsertionPointToStart(directNormalDest);
- builder.create<LLVM::BrOp>(loc, normalArgs, normalDest);
+ LLVM::BrOp::create(builder, loc, normalArgs, normalDest);
} else {
// If the invoke operation's result is not a block argument to the normal
// destination block, just add the block arguments as usual.
@@ -2416,8 +2417,8 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
}
Type type = convertType(inst->getType());
- auto gepOp = builder.create<GEPOp>(
- loc, type, sourceElementType, *basePtr, indices,
+ auto gepOp = GEPOp::create(
+ builder, loc, type, sourceElementType, *basePtr, indices,
static_cast<GEPNoWrapFlags>(gepInst->getNoWrapFlags().getRaw()));
mapValue(inst, gepOp);
return success();
@@ -2443,8 +2444,8 @@ LogicalResult ModuleImport::convertInstruction(llvm::Instruction *inst) {
SmallVector<ValueRange> succBlockArgsRange =
llvm::to_vector_of<ValueRange>(succBlockArgs);
Location loc = translateLoc(inst->getDebugLoc());
- auto indBrOp = builder.create<LLVM::IndirectBrOp>(
- loc, *basePtr, succBlockArgsRange, succBlocks);
+ auto indBrOp = LLVM::IndirectBrOp::create(builder, loc, *basePtr,
+ succBlockArgsRange, succBlocks);
mapNoResultOp(inst, indBrOp);
return success();
@@ -2888,8 +2889,8 @@ LogicalResult ModuleImport::processFunction(llvm::Function *func) {
builder.setInsertionPointToEnd(mlirModule.getBody());
Location loc = debugImporter->translateFuncLocation(func);
- LLVMFuncOp funcOp = builder.create<LLVMFuncOp>(
- loc, func->getName(), functionType,
+ LLVMFuncOp funcOp = LLVMFuncOp::create(
+ builder, loc, func->getName(), functionType,
convertLinkageFromLLVM(func->getLinkage()), dsoLocal, cconv);
convertParameterAttributes(func, funcOp, builder);
@@ -3066,12 +3067,12 @@ ModuleImport::processDebugIntrinsic(llvm::DbgVariableIntrinsic *dbgIntr,
Operation *op =
llvm::TypeSwitch<llvm::DbgVariableIntrinsic *, Operation *>(dbgIntr)
.Case([&](llvm::DbgDeclareInst *) {
- return builder.create<LLVM::DbgDeclareOp>(
- loc, *argOperand, localVariableAttr, locationExprAttr);
+ return LLVM::DbgDeclareOp::create(
+ builder, loc, *argOperand, localVariableAttr, locationExprAttr);
})
.Case([&](llvm::DbgValueInst *) {
- return builder.create<LLVM::DbgValueOp>(
- loc, *argOperand, localVariableAttr, locationExprAttr);
+ return LLVM::DbgValueOp::create(
+ builder, loc, *argOperand, localVariableAttr, locationExprAttr);
});...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/149933
More information about the Mlir-commits
mailing list