[flang-commits] [flang] [mlir][NFC] update `flang/lib` create APIs (12/n) (#149687) (PR #149914)
Maksim Levental via flang-commits
flang-commits at lists.llvm.org
Mon Jul 21 14:59:03 PDT 2025
https://github.com/makslevental created https://github.com/llvm/llvm-project/pull/149914
See https://github.com/llvm/llvm-project/pull/147168 for more info.
>From 1d837af11ba902e5b3b6f4700cf6d35084a02e96 Mon Sep 17 00:00:00 2001
From: max <maksim.levental at gmail.com>
Date: Mon, 21 Jul 2025 17:57:58 -0400
Subject: [PATCH] [mlir][NFC] update `flang/lib` create APIs (12/n) (#149687)
See https://github.com/llvm/llvm-project/pull/147168 for more info.
---
flang/lib/Frontend/FrontendActions.cpp | 2 +-
.../lib/Optimizer/CodeGen/BoxedProcedure.cpp | 8 +-
flang/lib/Optimizer/CodeGen/CodeGen.cpp | 332 +++++++++---------
flang/lib/Optimizer/CodeGen/FIROpPatterns.cpp | 32 +-
.../Optimizer/CodeGen/LowerRepackArrays.cpp | 32 +-
flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp | 12 +-
flang/lib/Optimizer/Dialect/FIRDialect.cpp | 2 +-
flang/lib/Optimizer/Dialect/FIROps.cpp | 16 +-
flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp | 4 +-
flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp | 6 +-
.../HLFIR/Transforms/BufferizeHLFIR.cpp | 38 +-
.../HLFIR/Transforms/ConvertToFIR.cpp | 70 ++--
.../HLFIR/Transforms/InlineHLFIRAssign.cpp | 2 +-
.../HLFIR/Transforms/InlineHLFIRCopyIn.cpp | 18 +-
.../HLFIR/Transforms/LowerHLFIRIntrinsics.cpp | 2 +-
.../LowerHLFIROrderedAssignments.cpp | 16 +-
.../Transforms/OptimizedBufferization.cpp | 12 +-
.../Transforms/SimplifyHLFIRIntrinsics.cpp | 166 ++++-----
.../Support/FIROpenACCTypeInterfaces.cpp | 42 +--
.../OpenMP/DoConcurrentConversion.cpp | 16 +-
.../Optimizer/OpenMP/FunctionFiltering.cpp | 2 +-
.../OpenMP/GenericLoopConversion.cpp | 10 +-
flang/lib/Optimizer/OpenMP/LowerWorkshare.cpp | 26 +-
.../Optimizer/OpenMP/MapInfoFinalization.cpp | 24 +-
.../OpenMP/MapsForPrivatizedSymbols.cpp | 6 +-
25 files changed, 448 insertions(+), 448 deletions(-)
diff --git a/flang/lib/Frontend/FrontendActions.cpp b/flang/lib/Frontend/FrontendActions.cpp
index b5f4f9421f633..99cc17fcfacc5 100644
--- a/flang/lib/Frontend/FrontendActions.cpp
+++ b/flang/lib/Frontend/FrontendActions.cpp
@@ -164,7 +164,7 @@ static void addDependentLibs(mlir::ModuleOp mlirModule, CompilerInstance &ci) {
// Add linker options specified by --dependent-lib
auto builder = mlir::OpBuilder(mlirModule.getRegion());
for (const std::string &lib : libs) {
- builder.create<mlir::LLVM::LinkerOptionsOp>(
+ mlir::LLVM::LinkerOptionsOp::create(builder,
mlirModule.getLoc(), builder.getStrArrayAttr({"/DEFAULTLIB:" + lib}));
}
}
diff --git a/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp b/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp
index 69bdb48146a54..9750f0750a4f7 100644
--- a/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp
+++ b/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp
@@ -180,7 +180,7 @@ class BoxprocTypeRewriter : public mlir::TypeConverter {
mlir::ValueRange inputs,
mlir::Location loc) {
assert(inputs.size() == 1);
- return builder.create<ConvertOp>(loc, unwrapRefType(type.getEleTy()),
+ return ConvertOp::create(builder, loc, unwrapRefType(type.getEleTy()),
inputs[0]);
}
@@ -282,16 +282,16 @@ class BoxedProcedurePass
// 32 bytes.
fir::SequenceType::Extent thunkSize = triple.getTrampolineSize();
mlir::Type buffTy = SequenceType::get({thunkSize}, i8Ty);
- auto buffer = builder.create<AllocaOp>(loc, buffTy);
+ auto buffer = AllocaOp::create(builder, loc, buffTy);
mlir::Value closure =
builder.createConvert(loc, i8Ptr, embox.getHost());
mlir::Value tramp = builder.createConvert(loc, i8Ptr, buffer);
mlir::Value func =
builder.createConvert(loc, i8Ptr, embox.getFunc());
- builder.create<fir::CallOp>(
+ fir::CallOp::create(builder,
loc, factory::getLlvmInitTrampoline(builder),
llvm::ArrayRef<mlir::Value>{tramp, func, closure});
- auto adjustCall = builder.create<fir::CallOp>(
+ auto adjustCall = fir::CallOp::create(builder,
loc, factory::getLlvmAdjustTrampoline(builder),
llvm::ArrayRef<mlir::Value>{tramp});
rewriter.replaceOpWithNewOp<ConvertOp>(embox, toTy,
diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
index 609ba27bc212b..1d80c5b44798f 100644
--- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp
+++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
@@ -92,7 +92,7 @@ genConstantIndex(mlir::Location loc, mlir::Type ity,
mlir::ConversionPatternRewriter &rewriter,
std::int64_t offset) {
auto cattr = rewriter.getI64IntegerAttr(offset);
- return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
+ return mlir::LLVM::ConstantOp::create(rewriter, loc, ity, cattr);
}
static mlir::Block *createBlock(mlir::ConversionPatternRewriter &rewriter,
@@ -148,27 +148,27 @@ mlir::Value replaceWithAddrOfOrASCast(mlir::ConversionPatternRewriter &rewriter,
mlir::Operation *replaceOp = nullptr) {
if (mlir::isa<mlir::LLVM::LLVMPointerType>(type)) {
if (globalAS != programAS) {
- auto llvmAddrOp = rewriter.create<mlir::LLVM::AddressOfOp>(
+ auto llvmAddrOp = mlir::LLVM::AddressOfOp::create(rewriter,
loc, getLlvmPtrType(rewriter.getContext(), globalAS), symName);
if (replaceOp)
return rewriter.replaceOpWithNewOp<mlir::LLVM::AddrSpaceCastOp>(
replaceOp, ::getLlvmPtrType(rewriter.getContext(), programAS),
llvmAddrOp);
- return rewriter.create<mlir::LLVM::AddrSpaceCastOp>(
+ return mlir::LLVM::AddrSpaceCastOp::create(rewriter,
loc, getLlvmPtrType(rewriter.getContext(), programAS), llvmAddrOp);
}
if (replaceOp)
return rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
replaceOp, getLlvmPtrType(rewriter.getContext(), globalAS), symName);
- return rewriter.create<mlir::LLVM::AddressOfOp>(
+ return mlir::LLVM::AddressOfOp::create(rewriter,
loc, getLlvmPtrType(rewriter.getContext(), globalAS), symName);
}
if (replaceOp)
return rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(replaceOp, type,
symName);
- return rewriter.create<mlir::LLVM::AddressOfOp>(loc, type, symName);
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, type, symName);
}
/// Lower `fir.address_of` operation to `llvm.address_of` operation.
@@ -250,7 +250,7 @@ struct DeclareOpConversion : public fir::FIROpConversion<fir::cg::XDeclareOp> {
if (auto varAttr =
mlir::dyn_cast_or_null<mlir::LLVM::DILocalVariableAttr>(
fusedLoc.getMetadata())) {
- rewriter.create<mlir::LLVM::DbgDeclareOp>(memRef.getLoc(), memRef,
+ mlir::LLVM::DbgDeclareOp::create(rewriter, memRef.getLoc(), memRef,
varAttr, nullptr);
}
}
@@ -294,7 +294,7 @@ struct AllocaOpConversion : public fir::FIROpConversion<fir::AllocaOp> {
emitError(loc, "did not find allocation function");
mlir::NamedAttribute attr = rewriter.getNamedAttr(
"callee", mlir::SymbolRefAttr::get(memSizeFn));
- auto call = rewriter.create<mlir::LLVM::CallOp>(
+ auto call = mlir::LLVM::CallOp::create(rewriter,
loc, ity, lenParams,
addLLVMOpBundleAttrs(rewriter, {attr}, lenParams.size()));
size = call.getResult();
@@ -339,7 +339,7 @@ struct AllocaOpConversion : public fir::FIROpConversion<fir::AllocaOp> {
// pointers! Only propagate pinned and bindc_name to help debugging, but
// this should have no functional purpose (and passing the operand segment
// attribute like before is certainly bad).
- auto llvmAlloc = rewriter.create<mlir::LLVM::AllocaOp>(
+ auto llvmAlloc = mlir::LLVM::AllocaOp::create(rewriter,
loc, ::getLlvmPtrType(alloc.getContext(), allocaAs), llvmObjectType,
size);
if (alloc.getPinned())
@@ -401,7 +401,7 @@ struct BoxCharLenOpConversion : public fir::FIROpConversion<fir::BoxCharLenOp> {
mlir::Type returnValTy = boxCharLen.getResult().getType();
constexpr int boxcharLenIdx = 1;
- auto len = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, boxChar,
+ auto len = mlir::LLVM::ExtractValueOp::create(rewriter, loc, boxChar,
boxcharLenIdx);
mlir::Value lenAfterCast = integerCast(loc, rewriter, returnValTy, len);
rewriter.replaceOp(boxCharLen, lenAfterCast);
@@ -597,9 +597,9 @@ struct StringLitOpConversion : public fir::FIROpConversion<fir::StringLitOp> {
unsigned bits = lowerTy().characterBitsize(charTy);
mlir::Type intTy = rewriter.getIntegerType(bits);
mlir::Location loc = constop.getLoc();
- mlir::Value cst = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
+ mlir::Value cst = mlir::LLVM::UndefOp::create(rewriter, loc, ty);
if (auto arr = mlir::dyn_cast<mlir::DenseElementsAttr>(attr)) {
- cst = rewriter.create<mlir::LLVM::ConstantOp>(loc, ty, arr);
+ cst = mlir::LLVM::ConstantOp::create(rewriter, loc, ty, arr);
} else if (auto arr = mlir::dyn_cast<mlir::ArrayAttr>(attr)) {
for (auto a : llvm::enumerate(arr.getValue())) {
// convert each character to a precise bitsize
@@ -608,8 +608,8 @@ struct StringLitOpConversion : public fir::FIROpConversion<fir::StringLitOp> {
mlir::cast<mlir::IntegerAttr>(a.value()).getValue().zextOrTrunc(
bits));
auto elemCst =
- rewriter.create<mlir::LLVM::ConstantOp>(loc, intTy, elemAttr);
- cst = rewriter.create<mlir::LLVM::InsertValueOp>(loc, cst, elemCst,
+ mlir::LLVM::ConstantOp::create(rewriter, loc, intTy, elemAttr);
+ cst = mlir::LLVM::InsertValueOp::create(rewriter, loc, cst, elemCst,
a.index());
}
} else {
@@ -706,14 +706,14 @@ struct CmpcOpConversion : public fir::FIROpConversion<fir::CmpcOp> {
mlir::arith::convertArithFastMathFlagsToLLVM(cmp.getFastmath());
mlir::LLVM::FCmpPredicate pred =
static_cast<mlir::LLVM::FCmpPredicate>(cmp.getPredicate());
- auto rcp = rewriter.create<mlir::LLVM::FCmpOp>(
+ auto rcp = mlir::LLVM::FCmpOp::create(rewriter,
loc, resTy, pred,
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, operands[0], 0),
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, operands[1], 0), fmf);
- auto icp = rewriter.create<mlir::LLVM::FCmpOp>(
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, operands[0], 0),
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, operands[1], 0), fmf);
+ auto icp = mlir::LLVM::FCmpOp::create(rewriter,
loc, resTy, pred,
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, operands[0], 1),
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, operands[1], 1), fmf);
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, operands[0], 1),
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, operands[1], 1), fmf);
llvm::SmallVector<mlir::Value, 2> cp = {rcp, icp};
switch (cmp.getPredicate()) {
case mlir::arith::CmpFPredicate::OEQ: // .EQ.
@@ -778,16 +778,16 @@ struct ConvertOpConversion : public fir::FIROpConversion<fir::ConvertOp> {
"incompatible record types");
auto toStTy = mlir::cast<mlir::LLVM::LLVMStructType>(toTy);
- mlir::Value val = rewriter.create<mlir::LLVM::UndefOp>(loc, toStTy);
+ mlir::Value val = mlir::LLVM::UndefOp::create(rewriter, loc, toStTy);
auto indexTypeMap = toStTy.getSubelementIndexMap();
assert(indexTypeMap.has_value() && "invalid record type");
for (auto [attr, type] : indexTypeMap.value()) {
int64_t index = mlir::cast<mlir::IntegerAttr>(attr).getInt();
auto extVal =
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, op0, index);
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, op0, index);
val =
- rewriter.create<mlir::LLVM::InsertValueOp>(loc, val, extVal, index);
+ mlir::LLVM::InsertValueOp::create(rewriter, loc, val, extVal, index);
}
rewriter.replaceOp(convert, val);
@@ -831,7 +831,7 @@ struct ConvertOpConversion : public fir::FIROpConversion<fir::ConvertOp> {
// Compare the input with zero.
mlir::Value zero = genConstantIndex(loc, fromTy, rewriter, 0);
- auto isTrue = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto isTrue = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::ne, op0, zero);
// Zero extend the i1 isTrue result to the required type (unless it is i1
@@ -859,23 +859,23 @@ struct ConvertOpConversion : public fir::FIROpConversion<fir::ConvertOp> {
return {};
}
if (fromBits > toBits)
- return rewriter.create<mlir::LLVM::FPTruncOp>(loc, toTy, val);
- return rewriter.create<mlir::LLVM::FPExtOp>(loc, toTy, val);
+ return mlir::LLVM::FPTruncOp::create(rewriter, loc, toTy, val);
+ return mlir::LLVM::FPExtOp::create(rewriter, loc, toTy, val);
};
// Complex to complex conversion.
if (fir::isa_complex(fromFirTy) && fir::isa_complex(toFirTy)) {
// Special case: handle the conversion of a complex such that both the
// real and imaginary parts are converted together.
auto ty = convertType(getComplexEleTy(convert.getValue().getType()));
- auto rp = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, op0, 0);
- auto ip = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, op0, 1);
+ auto rp = mlir::LLVM::ExtractValueOp::create(rewriter, loc, op0, 0);
+ auto ip = mlir::LLVM::ExtractValueOp::create(rewriter, loc, op0, 1);
auto nt = convertType(getComplexEleTy(convert.getRes().getType()));
auto fromBits = mlir::LLVM::getPrimitiveTypeSizeInBits(ty);
auto toBits = mlir::LLVM::getPrimitiveTypeSizeInBits(nt);
auto rc = convertFpToFp(rp, fromBits, toBits, nt);
auto ic = convertFpToFp(ip, fromBits, toBits, nt);
- auto un = rewriter.create<mlir::LLVM::UndefOp>(loc, toTy);
- auto i1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, un, rc, 0);
+ auto un = mlir::LLVM::UndefOp::create(rewriter, loc, toTy);
+ auto i1 = mlir::LLVM::InsertValueOp::create(rewriter, loc, un, rc, 0);
rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(convert, i1, ic,
1);
return mlir::success();
@@ -1023,7 +1023,7 @@ struct EmboxCharOpConversion : public fir::FIROpConversion<fir::EmboxCharOp> {
mlir::Location loc = emboxChar.getLoc();
mlir::Type llvmStructTy = convertType(emboxChar.getType());
- auto llvmStruct = rewriter.create<mlir::LLVM::UndefOp>(loc, llvmStructTy);
+ auto llvmStruct = mlir::LLVM::UndefOp::create(rewriter, loc, llvmStructTy);
mlir::Type lenTy =
mlir::cast<mlir::LLVM::LLVMStructType>(llvmStructTy).getBody()[1];
@@ -1033,9 +1033,9 @@ struct EmboxCharOpConversion : public fir::FIROpConversion<fir::EmboxCharOp> {
mlir::cast<mlir::LLVM::LLVMStructType>(llvmStructTy).getBody()[0];
if (addrTy != charBuffer.getType())
charBuffer =
- rewriter.create<mlir::LLVM::BitcastOp>(loc, addrTy, charBuffer);
+ mlir::LLVM::BitcastOp::create(rewriter, loc, addrTy, charBuffer);
- auto insertBufferOp = rewriter.create<mlir::LLVM::InsertValueOp>(
+ auto insertBufferOp = mlir::LLVM::InsertValueOp::create(rewriter,
loc, llvmStruct, charBuffer, 0);
rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
emboxChar, insertBufferOp, lenAfterCast, 1);
@@ -1059,7 +1059,7 @@ getMallocInModule(ModuleOp mod, fir::AllocMemOp op,
return mlir::SymbolRefAttr::get(userMalloc);
mlir::OpBuilder moduleBuilder(mod.getBodyRegion());
- auto mallocDecl = moduleBuilder.create<mlir::LLVM::LLVMFuncOp>(
+ auto mallocDecl = mlir::LLVM::LLVMFuncOp::create(moduleBuilder,
op.getLoc(), mallocName,
mlir::LLVM::LLVMFunctionType::get(getLlvmPtrType(op.getContext()),
indexType,
@@ -1120,9 +1120,9 @@ struct AllocMemOpConversion : public fir::FIROpConversion<fir::AllocMemOp> {
TODO(loc, "fir.allocmem codegen of derived type with length parameters");
mlir::Value size = genTypeSizeInBytes(loc, ity, rewriter, llvmObjectTy);
if (auto scaleSize = genAllocationScaleSize(heap, ity, rewriter))
- size = rewriter.create<mlir::LLVM::MulOp>(loc, ity, size, scaleSize);
+ size = mlir::LLVM::MulOp::create(rewriter, loc, ity, size, scaleSize);
for (mlir::Value opnd : adaptor.getOperands())
- size = rewriter.create<mlir::LLVM::MulOp>(
+ size = mlir::LLVM::MulOp::create(rewriter,
loc, ity, size, integerCast(loc, rewriter, ity, opnd));
// As the return value of malloc(0) is implementation defined, allocate one
@@ -1130,9 +1130,9 @@ struct AllocMemOpConversion : public fir::FIROpConversion<fir::AllocMemOp> {
// what the runtime has.
mlir::Value zero = genConstantIndex(loc, ity, rewriter, 0);
mlir::Value one = genConstantIndex(loc, ity, rewriter, 1);
- mlir::Value cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+ mlir::Value cmp = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sgt, size, zero);
- size = rewriter.create<mlir::LLVM::SelectOp>(loc, cmp, size, one);
+ size = mlir::LLVM::SelectOp::create(rewriter, loc, cmp, size, one);
auto mallocTyWidth = lowerTy().getIndexTypeBitwidth();
auto mallocTy =
@@ -1173,7 +1173,7 @@ getFreeInModule(ModuleOp mod, fir::FreeMemOp op,
// Create llvm declaration for free.
mlir::OpBuilder moduleBuilder(mod.getBodyRegion());
auto voidType = mlir::LLVM::LLVMVoidType::get(op.getContext());
- auto freeDecl = moduleBuilder.create<mlir::LLVM::LLVMFuncOp>(
+ auto freeDecl = mlir::LLVM::LLVMFuncOp::create(moduleBuilder,
rewriter.getUnknownLoc(), freeName,
mlir::LLVM::LLVMFunctionType::get(voidType,
getLlvmPtrType(op.getContext()),
@@ -1209,7 +1209,7 @@ struct FreeMemOpConversion : public fir::FIROpConversion<fir::FreeMemOp> {
mlir::ConversionPatternRewriter &rewriter) const override {
mlir::Location loc = freemem.getLoc();
freemem->setAttr("callee", getFree(freemem, rewriter));
- rewriter.create<mlir::LLVM::CallOp>(
+ mlir::LLVM::CallOp::create(rewriter,
loc, mlir::TypeRange{}, mlir::ValueRange{adaptor.getHeapref()},
addLLVMOpBundleAttrs(rewriter, freemem->getAttrs(), 1));
rewriter.eraseOp(freemem);
@@ -1265,38 +1265,38 @@ static mlir::Value genSourceFile(mlir::Location loc, mlir::ModuleOp mod,
std::string globalName = fir::factory::uniqueCGIdent("cl", fn);
if (auto g = mod.lookupSymbol<fir::GlobalOp>(globalName)) {
- return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ptrTy, g.getName());
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, ptrTy, g.getName());
} else if (auto g = mod.lookupSymbol<mlir::LLVM::GlobalOp>(globalName)) {
- return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ptrTy, g.getName());
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, ptrTy, g.getName());
}
auto crtInsPt = rewriter.saveInsertionPoint();
rewriter.setInsertionPoint(mod.getBody(), mod.getBody()->end());
auto arrayTy = mlir::LLVM::LLVMArrayType::get(
mlir::IntegerType::get(rewriter.getContext(), 8), fn.size());
- mlir::LLVM::GlobalOp globalOp = rewriter.create<mlir::LLVM::GlobalOp>(
+ mlir::LLVM::GlobalOp globalOp = mlir::LLVM::GlobalOp::create(rewriter,
loc, arrayTy, /*constant=*/true, mlir::LLVM::Linkage::Linkonce,
globalName, mlir::Attribute());
mlir::Region ®ion = globalOp.getInitializerRegion();
mlir::Block *block = rewriter.createBlock(®ion);
rewriter.setInsertionPoint(block, block->begin());
- mlir::Value constValue = rewriter.create<mlir::LLVM::ConstantOp>(
+ mlir::Value constValue = mlir::LLVM::ConstantOp::create(rewriter,
loc, arrayTy, rewriter.getStringAttr(fn));
- rewriter.create<mlir::LLVM::ReturnOp>(loc, constValue);
+ mlir::LLVM::ReturnOp::create(rewriter, loc, constValue);
rewriter.restoreInsertionPoint(crtInsPt);
- return rewriter.create<mlir::LLVM::AddressOfOp>(loc, ptrTy,
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, ptrTy,
globalOp.getName());
}
- return rewriter.create<mlir::LLVM::ZeroOp>(loc, ptrTy);
+ return mlir::LLVM::ZeroOp::create(rewriter, loc, ptrTy);
}
static mlir::Value genSourceLine(mlir::Location loc,
mlir::ConversionPatternRewriter &rewriter) {
if (auto flc = mlir::dyn_cast<mlir::FileLineColLoc>(loc))
- return rewriter.create<mlir::LLVM::ConstantOp>(loc, rewriter.getI32Type(),
+ return mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI32Type(),
flc.getLine());
- return rewriter.create<mlir::LLVM::ConstantOp>(loc, rewriter.getI32Type(), 0);
+ return mlir::LLVM::ConstantOp::create(rewriter, loc, rewriter.getI32Type(), 0);
}
static mlir::Value
@@ -1373,7 +1373,7 @@ getTypeDescriptor(ModOpTy mod, mlir::ConversionPatternRewriter &rewriter,
if (options.ignoreMissingTypeDescriptors ||
fir::NameUniquer::belongsToModule(
name, Fortran::semantics::typeInfoBuiltinModule))
- return rewriter.create<mlir::LLVM::ZeroOp>(loc, llvmPtrTy);
+ return mlir::LLVM::ZeroOp::create(rewriter, loc, llvmPtrTy);
if (!options.skipExternalRttiDefinition)
fir::emitFatalError(loc,
@@ -1386,11 +1386,11 @@ getTypeDescriptor(ModOpTy mod, mlir::ConversionPatternRewriter &rewriter,
// option. Generate the object declaration now.
auto insertPt = rewriter.saveInsertionPoint();
rewriter.setInsertionPoint(mod.getBody(), mod.getBody()->end());
- mlir::LLVM::GlobalOp global = rewriter.create<mlir::LLVM::GlobalOp>(
+ mlir::LLVM::GlobalOp global = mlir::LLVM::GlobalOp::create(rewriter,
loc, llvmPtrTy, /*constant=*/true, mlir::LLVM::Linkage::External, name,
mlir::Attribute());
rewriter.restoreInsertionPoint(insertPt);
- return rewriter.create<mlir::LLVM::AddressOfOp>(loc, llvmPtrTy,
+ return mlir::LLVM::AddressOfOp::create(rewriter, loc, llvmPtrTy,
global.getSymName());
}
@@ -1422,7 +1422,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
assert(!lenParams.empty());
auto len64 = fir::FIROpConversion<OP>::integerCast(loc, rewriter, i64Ty,
lenParams.back());
- return rewriter.create<mlir::LLVM::MulOp>(loc, i64Ty, size, len64);
+ return mlir::LLVM::MulOp::create(rewriter, loc, i64Ty, size, len64);
}
// Get the element size and CFI type code of the boxed value.
@@ -1437,7 +1437,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
return getSizeAndTypeCode(loc, rewriter, seqTy.getEleTy(), lenParams);
if (mlir::isa<mlir::NoneType>(
boxEleTy)) // unlimited polymorphic or assumed type
- return {rewriter.create<mlir::LLVM::ConstantOp>(loc, i64Ty, 0),
+ return {mlir::LLVM::ConstantOp::create(rewriter, loc, i64Ty, 0),
this->genConstantOffset(loc, rewriter, CFI_type_other)};
mlir::Value typeCodeVal = this->genConstantOffset(
loc, rewriter,
@@ -1473,7 +1473,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
if (!bitcast)
value = this->integerCast(loc, rewriter, fldTy, value);
// bitcast are no-ops with LLVM opaque pointers.
- return rewriter.create<mlir::LLVM::InsertValueOp>(loc, dest, value,
+ return mlir::LLVM::InsertValueOp::create(rewriter, loc, dest, value,
fldIndexes);
}
@@ -1518,7 +1518,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
bool isUnlimitedPolymorphic = fir::isUnlimitedPolymorphicType(boxTy);
bool useInputType = fir::isPolymorphicType(boxTy) || isUnlimitedPolymorphic;
mlir::Value descriptor =
- rewriter.create<mlir::LLVM::UndefOp>(loc, llvmBoxTy);
+ mlir::LLVM::UndefOp::create(rewriter, loc, llvmBoxTy);
descriptor =
insertField(rewriter, loc, descriptor, {kElemLenPosInBox}, eleSize);
descriptor = insertField(rewriter, loc, descriptor, {kVersionPosInBox},
@@ -1539,16 +1539,16 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
auto maskAttr = mlir::IntegerAttr::get(
rewriter.getIntegerType(8, /*isSigned=*/false),
llvm::APInt(8, (uint64_t)_CFI_ADDENDUM_FLAG, /*isSigned=*/false));
- mlir::LLVM::ConstantOp mask = rewriter.create<mlir::LLVM::ConstantOp>(
+ mlir::LLVM::ConstantOp mask = mlir::LLVM::ConstantOp::create(rewriter,
loc, rewriter.getI8Type(), maskAttr);
- extraField = rewriter.create<mlir::LLVM::OrOp>(loc, extraField, mask);
+ extraField = mlir::LLVM::OrOp::create(rewriter, loc, extraField, mask);
} else {
auto maskAttr = mlir::IntegerAttr::get(
rewriter.getIntegerType(8, /*isSigned=*/false),
llvm::APInt(8, (uint64_t)~_CFI_ADDENDUM_FLAG, /*isSigned=*/true));
- mlir::LLVM::ConstantOp mask = rewriter.create<mlir::LLVM::ConstantOp>(
+ mlir::LLVM::ConstantOp mask = mlir::LLVM::ConstantOp::create(rewriter,
loc, rewriter.getI8Type(), maskAttr);
- extraField = rewriter.create<mlir::LLVM::AndOp>(loc, extraField, mask);
+ extraField = mlir::LLVM::AndOp::create(rewriter, loc, extraField, mask);
}
// Extra field value is provided so just use it.
descriptor =
@@ -1575,7 +1575,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
} else {
// Unlimited polymorphic type descriptor with no record type. Set
// type descriptor address to a clean state.
- typeDesc = rewriter.create<mlir::LLVM::ZeroOp>(
+ typeDesc = mlir::LLVM::ZeroOp::create(rewriter,
loc, ::getLlvmPtrType(mod.getContext()));
}
} else {
@@ -1756,12 +1756,12 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
mlir::Value cast =
this->integerCast(loc, rewriter, outterOffsetTy, *substringOffset);
- gepArgs[0] = rewriter.create<mlir::LLVM::AddOp>(
+ gepArgs[0] = mlir::LLVM::AddOp::create(rewriter,
loc, outterOffsetTy, llvm::cast<mlir::Value>(gepArgs[0]), cast);
}
}
mlir::Type llvmPtrTy = ::getLlvmPtrType(resultTy.getContext());
- return rewriter.create<mlir::LLVM::GEPOp>(
+ return mlir::LLVM::GEPOp::create(rewriter,
loc, llvmPtrTy, llvmBaseObjectType, base, gepArgs);
}
@@ -1809,7 +1809,7 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
storage = this->genAllocaAndAddrCastWithType(loc, llvmBoxTy, defaultAlign,
rewriter);
}
- auto storeOp = rewriter.create<mlir::LLVM::StoreOp>(loc, boxValue, storage);
+ auto storeOp = mlir::LLVM::StoreOp::create(rewriter, loc, boxValue, storage);
this->attachTBAATag(storeOp, boxTy, boxTy, nullptr);
return storage;
}
@@ -1823,14 +1823,14 @@ struct EmboxCommonConversion : public fir::FIROpConversion<OP> {
ub = this->integerCast(loc, rewriter, type, ub);
step = this->integerCast(loc, rewriter, type, step);
zero = this->integerCast(loc, rewriter, type, zero);
- mlir::Value extent = rewriter.create<mlir::LLVM::SubOp>(loc, type, ub, lb);
- extent = rewriter.create<mlir::LLVM::AddOp>(loc, type, extent, step);
- extent = rewriter.create<mlir::LLVM::SDivOp>(loc, type, extent, step);
+ mlir::Value extent = mlir::LLVM::SubOp::create(rewriter, loc, type, ub, lb);
+ extent = mlir::LLVM::AddOp::create(rewriter, loc, type, extent, step);
+ extent = mlir::LLVM::SDivOp::create(rewriter, loc, type, extent, step);
// If the resulting extent is negative (`ub-lb` and `step` have different
// signs), zero must be returned instead.
- auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sgt, extent, zero);
- return rewriter.create<mlir::LLVM::SelectOp>(loc, cmp, extent, zero);
+ return mlir::LLVM::SelectOp::create(rewriter, loc, cmp, extent, zero);
}
};
@@ -2005,14 +2005,14 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
mlir::Value adj = one;
if (hasShift)
adj = integerCast(loc, rewriter, i64Ty, operands[shiftOffset]);
- auto ao = rewriter.create<mlir::LLVM::SubOp>(loc, i64Ty, off, adj);
+ auto ao = mlir::LLVM::SubOp::create(rewriter, loc, i64Ty, off, adj);
if (constRows > 0) {
cstInteriorIndices.push_back(ao);
} else {
auto dimOff =
- rewriter.create<mlir::LLVM::MulOp>(loc, i64Ty, ao, prevPtrOff);
+ mlir::LLVM::MulOp::create(rewriter, loc, i64Ty, ao, prevPtrOff);
ptrOffset =
- rewriter.create<mlir::LLVM::AddOp>(loc, i64Ty, dimOff, ptrOffset);
+ mlir::LLVM::AddOp::create(rewriter, loc, i64Ty, dimOff, ptrOffset);
}
if (mlir::isa_and_nonnull<fir::UndefOp>(
xbox.getSlice()[3 * di + 1].getDefiningOp())) {
@@ -2042,9 +2042,9 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
if (hasShift && !(hasSlice || hasSubcomp || hasSubstr) &&
(isaPointerOrAllocatable || !normalizedLowerBound(xbox))) {
lb = integerCast(loc, rewriter, i64Ty, operands[shiftOffset]);
- auto extentIsEmpty = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto extentIsEmpty = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::eq, extent, zero);
- lb = rewriter.create<mlir::LLVM::SelectOp>(loc, extentIsEmpty, one,
+ lb = mlir::LLVM::SelectOp::create(rewriter, loc, extentIsEmpty, one,
lb);
}
dest = insertLowerBound(rewriter, loc, dest, descIdx, lb);
@@ -2057,17 +2057,17 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
mlir::Value sliceStep =
integerCast(loc, rewriter, i64Ty, operands[sliceOffset + 2]);
step =
- rewriter.create<mlir::LLVM::MulOp>(loc, i64Ty, step, sliceStep);
+ mlir::LLVM::MulOp::create(rewriter, loc, i64Ty, step, sliceStep);
}
dest = insertStride(rewriter, loc, dest, descIdx, step);
++descIdx;
}
// compute the stride and offset for the next natural dimension
- prevDimByteStride = rewriter.create<mlir::LLVM::MulOp>(
+ prevDimByteStride = mlir::LLVM::MulOp::create(rewriter,
loc, i64Ty, prevDimByteStride, outerExtent);
if (constRows == 0)
- prevPtrOff = rewriter.create<mlir::LLVM::MulOp>(loc, i64Ty, prevPtrOff,
+ prevPtrOff = mlir::LLVM::MulOp::create(rewriter, loc, i64Ty, prevPtrOff,
outerExtent);
else
--constRows;
@@ -2153,7 +2153,7 @@ struct XReboxOpConversion : public EmboxCommonConversion<fir::cg::XReboxOp> {
"character target in global op must have constant length");
mlir::Value width =
genConstantIndex(loc, idxTy, rewriter, charTy.getFKind());
- len = rewriter.create<mlir::LLVM::SDivOp>(loc, idxTy, len, width);
+ len = mlir::LLVM::SDivOp::create(rewriter, loc, idxTy, len, width);
}
lenParams.emplace_back(len);
}
@@ -2214,9 +2214,9 @@ struct XReboxOpConversion : public EmboxCommonConversion<fir::cg::XReboxOp> {
mlir::Value lb = one;
if (!lbounds.empty()) {
lb = integerCast(loc, rewriter, lowerTy().indexType(), lbounds[dim]);
- auto extentIsEmpty = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto extentIsEmpty = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::eq, extent, zero);
- lb = rewriter.create<mlir::LLVM::SelectOp>(loc, extentIsEmpty, one, lb);
+ lb = mlir::LLVM::SelectOp::create(rewriter, loc, extentIsEmpty, one, lb);
};
dest = insertLowerBound(rewriter, loc, dest, dim, lb);
dest = insertExtent(rewriter, loc, dest, dim, extent);
@@ -2284,9 +2284,9 @@ struct XReboxOpConversion : public EmboxCommonConversion<fir::cg::XReboxOp> {
? integerCast(loc, rewriter, idxTy, operands[shiftOps])
: one;
mlir::Value diff =
- rewriter.create<mlir::LLVM::SubOp>(loc, idxTy, sliceLb, sliceOrigin);
+ mlir::LLVM::SubOp::create(rewriter, loc, idxTy, sliceLb, sliceOrigin);
mlir::Value offset =
- rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, diff, inputStride);
+ mlir::LLVM::MulOp::create(rewriter, loc, idxTy, diff, inputStride);
// Strides from the fir.box are in bytes.
base = genGEP(loc, byteTy, rewriter, base, offset);
// Apply upper bound and step if this is a triplet. Otherwise, the
@@ -2304,7 +2304,7 @@ struct XReboxOpConversion : public EmboxCommonConversion<fir::cg::XReboxOp> {
slicedExtents.emplace_back(extent);
// stride = step*input_stride
mlir::Value stride =
- rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, step, inputStride);
+ mlir::LLVM::MulOp::create(rewriter, loc, idxTy, step, inputStride);
slicedStrides.emplace_back(stride);
}
}
@@ -2348,7 +2348,7 @@ struct XReboxOpConversion : public EmboxCommonConversion<fir::cg::XReboxOp> {
newExtents.emplace_back(extent);
newStrides.emplace_back(stride);
// nextStride = extent * stride;
- stride = rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, extent, stride);
+ stride = mlir::LLVM::MulOp::create(rewriter, loc, idxTy, extent, stride);
}
return finalizeRebox(rebox, adaptor, destBoxTy, dest, base, reboxShifts,
newExtents, newStrides, rewriter);
@@ -2536,7 +2536,7 @@ struct InsertOnRangeOpConversion
mlir::Value insertVal = adaptor.getVal();
while (subscripts != uBounds) {
- lastOp = rewriter.create<mlir::LLVM::InsertValueOp>(
+ lastOp = mlir::LLVM::InsertValueOp::create(rewriter,
loc, lastOp, insertVal, subscripts);
incrementSubscripts(dims, subscripts);
@@ -2606,15 +2606,15 @@ struct XArrayCoorOpConversion
if (normalSlice)
step = integerCast(loc, rewriter, idxTy, operands[sliceOffset + 2]);
}
- auto idx = rewriter.create<mlir::LLVM::SubOp>(loc, idxTy, index, lb, nsw);
+ auto idx = mlir::LLVM::SubOp::create(rewriter, loc, idxTy, index, lb, nsw);
mlir::Value diff =
- rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, idx, step, nsw);
+ mlir::LLVM::MulOp::create(rewriter, loc, idxTy, idx, step, nsw);
if (normalSlice) {
mlir::Value sliceLb =
integerCast(loc, rewriter, idxTy, operands[sliceOffset]);
auto adj =
- rewriter.create<mlir::LLVM::SubOp>(loc, idxTy, sliceLb, lb, nsw);
- diff = rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, diff, adj, nsw);
+ mlir::LLVM::SubOp::create(rewriter, loc, idxTy, sliceLb, lb, nsw);
+ diff = mlir::LLVM::AddOp::create(rewriter, loc, idxTy, diff, adj, nsw);
}
// Update the offset given the stride and the zero based index `diff`
// that was just computed.
@@ -2623,19 +2623,19 @@ struct XArrayCoorOpConversion
mlir::Value stride =
getStrideFromBox(loc, baseBoxTyPair, operands[0], i, rewriter);
auto sc =
- rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, diff, stride, nsw);
+ mlir::LLVM::MulOp::create(rewriter, loc, idxTy, diff, stride, nsw);
offset =
- rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, sc, offset, nsw);
+ mlir::LLVM::AddOp::create(rewriter, loc, idxTy, sc, offset, nsw);
} else {
// Use stride computed at last iteration.
auto sc =
- rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, diff, prevExt, nsw);
+ mlir::LLVM::MulOp::create(rewriter, loc, idxTy, diff, prevExt, nsw);
offset =
- rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, sc, offset, nsw);
+ mlir::LLVM::AddOp::create(rewriter, loc, idxTy, sc, offset, nsw);
// Compute next stride assuming contiguity of the base array
// (in element number).
auto nextExt = integerCast(loc, rewriter, idxTy, operands[shapeOffset]);
- prevExt = rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, prevExt,
+ prevExt = mlir::LLVM::MulOp::create(rewriter, loc, idxTy, prevExt,
nextExt, nsw);
}
}
@@ -2648,7 +2648,7 @@ struct XArrayCoorOpConversion
mlir::Value base =
getBaseAddrFromBox(loc, baseBoxTyPair, operands[0], rewriter);
llvm::SmallVector<mlir::LLVM::GEPArg> args{offset};
- auto addr = rewriter.create<mlir::LLVM::GEPOp>(loc, llvmPtrTy, byteTy,
+ auto addr = mlir::LLVM::GEPOp::create(rewriter, loc, llvmPtrTy, byteTy,
base, args);
if (coor.getSubcomponent().empty()) {
rewriter.replaceOp(coor, addr);
@@ -2696,7 +2696,7 @@ struct XArrayCoorOpConversion
assert(coor.getLenParams().size() == 1);
auto length = integerCast(loc, rewriter, idxTy,
operands[coor.getLenParamsOperandIndex()]);
- offset = rewriter.create<mlir::LLVM::MulOp>(loc, idxTy, offset,
+ offset = mlir::LLVM::MulOp::create(rewriter, loc, idxTy, offset,
length, nsw);
} else {
TODO(loc, "compute size of derived type with type parameters");
@@ -2912,12 +2912,12 @@ struct CoordinateOpConversion
for (unsigned dim = 0; dim < arrayDim && it != end; ++dim, ++it) {
mlir::Value stride =
getStrideFromBox(loc, boxTyPair, operands[0], dim, rewriter);
- auto sc = rewriter.create<mlir::LLVM::MulOp>(
+ auto sc = mlir::LLVM::MulOp::create(rewriter,
loc, idxTy, operands[nextIndexValue + dim], stride, nsw);
- off = rewriter.create<mlir::LLVM::AddOp>(loc, idxTy, sc, off, nsw);
+ off = mlir::LLVM::AddOp::create(rewriter, loc, idxTy, sc, off, nsw);
}
nextIndexValue += arrayDim;
- resultAddr = rewriter.create<mlir::LLVM::GEPOp>(
+ resultAddr = mlir::LLVM::GEPOp::create(rewriter,
loc, llvmPtrTy, byteTy, resultAddr,
llvm::ArrayRef<mlir::LLVM::GEPArg>{off});
cpnTy = arrTy.getEleTy();
@@ -2930,7 +2930,7 @@ struct CoordinateOpConversion
++it;
cpnTy = recTy.getType(fieldIndex);
auto llvmRecTy = lowerTy().convertType(recTy);
- resultAddr = rewriter.create<mlir::LLVM::GEPOp>(
+ resultAddr = mlir::LLVM::GEPOp::create(rewriter,
loc, llvmPtrTy, llvmRecTy, resultAddr,
llvm::ArrayRef<mlir::LLVM::GEPArg>{0, fieldIndex});
} else {
@@ -3184,7 +3184,7 @@ struct GlobalOpConversion : public fir::FIROpConversion<fir::GlobalOp> {
auto isConst = global.getConstant().has_value();
mlir::SymbolRefAttr comdat;
llvm::ArrayRef<mlir::NamedAttribute> attrs;
- auto g = rewriter.create<mlir::LLVM::GlobalOp>(
+ auto g = mlir::LLVM::GlobalOp::create(rewriter,
loc, tyAttr, isConst, linkage, global.getSymName(), initAttr, 0,
getGlobalAddressSpace(rewriter), false, false, comdat, attrs, dbgExprs);
@@ -3276,14 +3276,14 @@ struct GlobalOpConversion : public fir::FIROpConversion<fir::GlobalOp> {
module.lookupSymbol<mlir::LLVM::ComdatOp>(comdatName);
if (!comdatOp) {
comdatOp =
- rewriter.create<mlir::LLVM::ComdatOp>(module.getLoc(), comdatName);
+ mlir::LLVM::ComdatOp::create(rewriter, module.getLoc(), comdatName);
}
if (auto select = comdatOp.lookupSymbol<mlir::LLVM::ComdatSelectorOp>(
global.getSymName()))
return;
mlir::OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToEnd(&comdatOp.getBody().back());
- auto selectorOp = rewriter.create<mlir::LLVM::ComdatSelectorOp>(
+ auto selectorOp = mlir::LLVM::ComdatSelectorOp::create(rewriter,
comdatOp.getLoc(), global.getSymName(),
mlir::LLVM::comdat::Comdat::Any);
global.setComdatAttr(mlir::SymbolRefAttr::get(
@@ -3331,7 +3331,7 @@ struct LoadOpConversion : public fir::FIROpConversion<fir::LoadOp> {
TypePair boxTypePair{boxTy, llvmLoadTy};
mlir::Value boxSize =
computeBoxSize(loc, boxTypePair, inputBoxStorage, rewriter);
- auto memcpy = rewriter.create<mlir::LLVM::MemcpyOp>(
+ auto memcpy = mlir::LLVM::MemcpyOp::create(rewriter,
loc, newBoxStorage, inputBoxStorage, boxSize, isVolatile);
if (std::optional<mlir::ArrayAttr> optionalTag = load.getTbaa())
@@ -3340,7 +3340,7 @@ struct LoadOpConversion : public fir::FIROpConversion<fir::LoadOp> {
attachTBAATag(memcpy, boxTy, boxTy, nullptr);
rewriter.replaceOp(load, newBoxStorage);
} else {
- mlir::LLVM::LoadOp loadOp = rewriter.create<mlir::LLVM::LoadOp>(
+ mlir::LLVM::LoadOp loadOp = mlir::LLVM::LoadOp::create(rewriter,
load.getLoc(), llvmLoadTy, adaptor.getOperands(), load->getAttrs());
loadOp.setVolatile_(isVolatile);
if (std::optional<mlir::ArrayAttr> optionalTag = load.getTbaa())
@@ -3396,10 +3396,10 @@ static void genCondBrOp(mlir::Location loc, mlir::Value cmp, mlir::Block *dest,
mlir::ConversionPatternRewriter &rewriter,
mlir::Block *newBlock) {
if (destOps)
- rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, *destOps, newBlock,
+ mlir::LLVM::CondBrOp::create(rewriter, loc, cmp, dest, *destOps, newBlock,
mlir::ValueRange());
else
- rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, newBlock);
+ mlir::LLVM::CondBrOp::create(rewriter, loc, cmp, dest, newBlock);
}
template <typename A, typename B>
@@ -3466,35 +3466,35 @@ struct SelectCaseOpConversion : public fir::FIROpConversion<fir::SelectCaseOp> {
mlir::Attribute attr = cases[t];
assert(mlir::isa<mlir::UnitAttr>(attr) || cmpOps.has_value());
if (mlir::isa<fir::PointIntervalAttr>(attr)) {
- auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::eq, selector, cmpOps->front());
genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
continue;
}
if (mlir::isa<fir::LowerBoundAttr>(attr)) {
- auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sle, cmpOps->front(), selector);
genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
continue;
}
if (mlir::isa<fir::UpperBoundAttr>(attr)) {
- auto cmp = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sle, selector, cmpOps->front());
genCaseLadderStep(loc, cmp, dest, destOps, rewriter);
continue;
}
if (mlir::isa<fir::ClosedIntervalAttr>(attr)) {
mlir::Value caseArg0 = *cmpOps->begin();
- auto cmp0 = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp0 = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sle, caseArg0, selector);
auto *thisBlock = rewriter.getInsertionBlock();
auto *newBlock1 = createBlock(rewriter, dest);
auto *newBlock2 = createBlock(rewriter, dest);
rewriter.setInsertionPointToEnd(thisBlock);
- rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp0, newBlock1, newBlock2);
+ mlir::LLVM::CondBrOp::create(rewriter, loc, cmp0, newBlock1, newBlock2);
rewriter.setInsertionPointToEnd(newBlock1);
mlir::Value caseArg1 = *(cmpOps->begin() + 1);
- auto cmp1 = rewriter.create<mlir::LLVM::ICmpOp>(
+ auto cmp1 = mlir::LLVM::ICmpOp::create(rewriter,
loc, mlir::LLVM::ICmpPredicate::sle, selector, caseArg1);
genCondBrOp(loc, cmp1, dest, destOps, rewriter, newBlock2);
rewriter.setInsertionPointToEnd(newBlock2);
@@ -3581,7 +3581,7 @@ selectMatchAndRewrite(const fir::LLVMTypeConverter &lowering, OP select,
// LLVM::SwitchOp takes a i32 type for the selector.
if (select.getSelector().getType() != rewriter.getI32Type())
- selector = rewriter.create<mlir::LLVM::TruncOp>(loc, rewriter.getI32Type(),
+ selector = mlir::LLVM::TruncOp::create(rewriter, loc, rewriter.getI32Type(),
selector);
rewriter.replaceOpWithNewOp<mlir::LLVM::SwitchOp>(
@@ -3654,11 +3654,11 @@ struct StoreOpConversion : public fir::FIROpConversion<fir::StoreOp> {
TypePair boxTypePair{boxTy, llvmBoxTy};
mlir::Value boxSize =
computeBoxSize(loc, boxTypePair, llvmValue, rewriter);
- newOp = rewriter.create<mlir::LLVM::MemcpyOp>(loc, llvmMemref, llvmValue,
+ newOp = mlir::LLVM::MemcpyOp::create(rewriter, loc, llvmMemref, llvmValue,
boxSize, isVolatile);
} else {
mlir::LLVM::StoreOp storeOp =
- rewriter.create<mlir::LLVM::StoreOp>(loc, llvmValue, llvmMemref);
+ mlir::LLVM::StoreOp::create(rewriter, loc, llvmValue, llvmMemref);
if (isVolatile)
storeOp.setVolatile_(true);
@@ -3697,10 +3697,10 @@ struct CopyOpConversion : public fir::FIROpConversion<fir::CopyOp> {
mlir::LLVM::AliasAnalysisOpInterface newOp;
if (copy.getNoOverlap())
- newOp = rewriter.create<mlir::LLVM::MemcpyOp>(
+ newOp = mlir::LLVM::MemcpyOp::create(rewriter,
loc, llvmDestination, llvmSource, copySize, isVolatile);
else
- newOp = rewriter.create<mlir::LLVM::MemmoveOp>(
+ newOp = mlir::LLVM::MemmoveOp::create(rewriter,
loc, llvmDestination, llvmSource, copySize, isVolatile);
// TODO: propagate TBAA once FirAliasTagOpInterface added to CopyOp.
@@ -3725,9 +3725,9 @@ struct UnboxCharOpConversion : public fir::FIROpConversion<fir::UnboxCharOp> {
mlir::Location loc = unboxchar.getLoc();
mlir::Value ptrToBuffer =
- rewriter.create<mlir::LLVM::ExtractValueOp>(loc, tuple, 0);
+ mlir::LLVM::ExtractValueOp::create(rewriter, loc, tuple, 0);
- auto len = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, tuple, 1);
+ auto len = mlir::LLVM::ExtractValueOp::create(rewriter, loc, tuple, 1);
mlir::Value lenAfterCast = integerCast(loc, rewriter, lenTy, len);
rewriter.replaceOp(unboxchar,
@@ -3817,11 +3817,11 @@ struct IsPresentOpConversion : public fir::FIROpConversion<fir::IsPresentOp> {
mlir::cast<mlir::LLVM::LLVMStructType>(ptr.getType());
assert(!structTy.isOpaque() && !structTy.getBody().empty());
- ptr = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ptr, 0);
+ ptr = mlir::LLVM::ExtractValueOp::create(rewriter, loc, ptr, 0);
}
mlir::LLVM::ConstantOp c0 =
genConstantIndex(isPresent.getLoc(), idxTy, rewriter, 0);
- auto addr = rewriter.create<mlir::LLVM::PtrToIntOp>(loc, idxTy, ptr);
+ auto addr = mlir::LLVM::PtrToIntOp::create(rewriter, loc, idxTy, ptr);
rewriter.replaceOpWithNewOp<mlir::LLVM::ICmpOp>(
isPresent, mlir::LLVM::ICmpPredicate::ne, addr, c0);
@@ -3866,15 +3866,15 @@ complexSum(OPTY sumop, mlir::ValueRange opnds,
auto loc = sumop.getLoc();
mlir::Type eleTy = lowering.convertType(getComplexEleTy(sumop.getType()));
mlir::Type ty = lowering.convertType(sumop.getType());
- auto x0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 0);
- auto y0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 1);
- auto x1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 0);
- auto y1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 1);
- auto rx = rewriter.create<LLVMOP>(loc, eleTy, x0, x1, fmf);
- auto ry = rewriter.create<LLVMOP>(loc, eleTy, y0, y1, fmf);
- auto r0 = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
- auto r1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, r0, rx, 0);
- return rewriter.create<mlir::LLVM::InsertValueOp>(loc, r1, ry, 1);
+ auto x0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 0);
+ auto y0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 1);
+ auto x1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 0);
+ auto y1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 1);
+ auto rx = LLVMOP::create(rewriter, loc, eleTy, x0, x1, fmf);
+ auto ry = LLVMOP::create(rewriter, loc, eleTy, y0, y1, fmf);
+ auto r0 = mlir::LLVM::UndefOp::create(rewriter, loc, ty);
+ auto r1 = mlir::LLVM::InsertValueOp::create(rewriter, loc, r0, rx, 0);
+ return mlir::LLVM::InsertValueOp::create(rewriter, loc, r1, ry, 1);
}
} // namespace
@@ -3925,19 +3925,19 @@ struct MulcOpConversion : public fir::FIROpConversion<fir::MulcOp> {
auto loc = mulc.getLoc();
mlir::Type eleTy = convertType(getComplexEleTy(mulc.getType()));
mlir::Type ty = convertType(mulc.getType());
- auto x0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 0);
- auto y0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 1);
- auto x1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 0);
- auto y1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 1);
- auto xx = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x0, x1, fmf);
- auto yx = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y0, x1, fmf);
- auto xy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x0, y1, fmf);
- auto ri = rewriter.create<mlir::LLVM::FAddOp>(loc, eleTy, xy, yx, fmf);
- auto yy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y0, y1, fmf);
- auto rr = rewriter.create<mlir::LLVM::FSubOp>(loc, eleTy, xx, yy, fmf);
- auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
- auto r1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ra, rr, 0);
- auto r0 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, r1, ri, 1);
+ auto x0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 0);
+ auto y0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 1);
+ auto x1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 0);
+ auto y1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 1);
+ auto xx = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, x0, x1, fmf);
+ auto yx = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, y0, x1, fmf);
+ auto xy = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, x0, y1, fmf);
+ auto ri = mlir::LLVM::FAddOp::create(rewriter, loc, eleTy, xy, yx, fmf);
+ auto yy = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, y0, y1, fmf);
+ auto rr = mlir::LLVM::FSubOp::create(rewriter, loc, eleTy, xx, yy, fmf);
+ auto ra = mlir::LLVM::UndefOp::create(rewriter, loc, ty);
+ auto r1 = mlir::LLVM::InsertValueOp::create(rewriter, loc, ra, rr, 0);
+ auto r0 = mlir::LLVM::InsertValueOp::create(rewriter, loc, r1, ri, 1);
rewriter.replaceOp(mulc, r0.getResult());
return mlir::success();
}
@@ -3960,24 +3960,24 @@ struct DivcOpConversion : public fir::FIROpConversion<fir::DivcOp> {
auto loc = divc.getLoc();
mlir::Type eleTy = convertType(getComplexEleTy(divc.getType()));
mlir::Type ty = convertType(divc.getType());
- auto x0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 0);
- auto y0 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, a, 1);
- auto x1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 0);
- auto y1 = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, b, 1);
- auto xx = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x0, x1, fmf);
- auto x1x1 = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x1, x1, fmf);
- auto yx = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y0, x1, fmf);
- auto xy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, x0, y1, fmf);
- auto yy = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y0, y1, fmf);
- auto y1y1 = rewriter.create<mlir::LLVM::FMulOp>(loc, eleTy, y1, y1, fmf);
- auto d = rewriter.create<mlir::LLVM::FAddOp>(loc, eleTy, x1x1, y1y1, fmf);
- auto rrn = rewriter.create<mlir::LLVM::FAddOp>(loc, eleTy, xx, yy, fmf);
- auto rin = rewriter.create<mlir::LLVM::FSubOp>(loc, eleTy, yx, xy, fmf);
- auto rr = rewriter.create<mlir::LLVM::FDivOp>(loc, eleTy, rrn, d, fmf);
- auto ri = rewriter.create<mlir::LLVM::FDivOp>(loc, eleTy, rin, d, fmf);
- auto ra = rewriter.create<mlir::LLVM::UndefOp>(loc, ty);
- auto r1 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, ra, rr, 0);
- auto r0 = rewriter.create<mlir::LLVM::InsertValueOp>(loc, r1, ri, 1);
+ auto x0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 0);
+ auto y0 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, a, 1);
+ auto x1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 0);
+ auto y1 = mlir::LLVM::ExtractValueOp::create(rewriter, loc, b, 1);
+ auto xx = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, x0, x1, fmf);
+ auto x1x1 = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, x1, x1, fmf);
+ auto yx = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, y0, x1, fmf);
+ auto xy = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, x0, y1, fmf);
+ auto yy = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, y0, y1, fmf);
+ auto y1y1 = mlir::LLVM::FMulOp::create(rewriter, loc, eleTy, y1, y1, fmf);
+ auto d = mlir::LLVM::FAddOp::create(rewriter, loc, eleTy, x1x1, y1y1, fmf);
+ auto rrn = mlir::LLVM::FAddOp::create(rewriter, loc, eleTy, xx, yy, fmf);
+ auto rin = mlir::LLVM::FSubOp::create(rewriter, loc, eleTy, yx, xy, fmf);
+ auto rr = mlir::LLVM::FDivOp::create(rewriter, loc, eleTy, rrn, d, fmf);
+ auto ri = mlir::LLVM::FDivOp::create(rewriter, loc, eleTy, rin, d, fmf);
+ auto ra = mlir::LLVM::UndefOp::create(rewriter, loc, ty);
+ auto r1 = mlir::LLVM::InsertValueOp::create(rewriter, loc, ra, rr, 0);
+ auto r0 = mlir::LLVM::InsertValueOp::create(rewriter, loc, r1, ri, 1);
rewriter.replaceOp(divc, r0.getResult());
return mlir::success();
}
@@ -3995,11 +3995,11 @@ struct NegcOpConversion : public fir::FIROpConversion<fir::NegcOp> {
auto eleTy = convertType(getComplexEleTy(neg.getType()));
auto loc = neg.getLoc();
mlir::Value o0 = adaptor.getOperands()[0];
- auto rp = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, o0, 0);
- auto ip = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, o0, 1);
- auto nrp = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, rp);
- auto nip = rewriter.create<mlir::LLVM::FNegOp>(loc, eleTy, ip);
- auto r = rewriter.create<mlir::LLVM::InsertValueOp>(loc, o0, nrp, 0);
+ auto rp = mlir::LLVM::ExtractValueOp::create(rewriter, loc, o0, 0);
+ auto ip = mlir::LLVM::ExtractValueOp::create(rewriter, loc, o0, 1);
+ auto nrp = mlir::LLVM::FNegOp::create(rewriter, loc, eleTy, rp);
+ auto nip = mlir::LLVM::FNegOp::create(rewriter, loc, eleTy, ip);
+ auto r = mlir::LLVM::InsertValueOp::create(rewriter, loc, o0, nrp, 0);
rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(neg, r, nip, 1);
return mlir::success();
}
diff --git a/flang/lib/Optimizer/CodeGen/FIROpPatterns.cpp b/flang/lib/Optimizer/CodeGen/FIROpPatterns.cpp
index 75a54fd0ee14f..ea234e20c6856 100644
--- a/flang/lib/Optimizer/CodeGen/FIROpPatterns.cpp
+++ b/flang/lib/Optimizer/CodeGen/FIROpPatterns.cpp
@@ -48,7 +48,7 @@ mlir::LLVM::ConstantOp ConvertFIRToLLVMPattern::genI32Constant(
int value) const {
mlir::Type i32Ty = rewriter.getI32Type();
mlir::IntegerAttr attr = rewriter.getI32IntegerAttr(value);
- return rewriter.create<mlir::LLVM::ConstantOp>(loc, i32Ty, attr);
+ return mlir::LLVM::ConstantOp::create(rewriter, loc, i32Ty, attr);
}
mlir::LLVM::ConstantOp ConvertFIRToLLVMPattern::genConstantOffset(
@@ -56,7 +56,7 @@ mlir::LLVM::ConstantOp ConvertFIRToLLVMPattern::genConstantOffset(
int offset) const {
mlir::Type ity = lowerTy().offsetType();
mlir::IntegerAttr cattr = rewriter.getI32IntegerAttr(offset);
- return rewriter.create<mlir::LLVM::ConstantOp>(loc, ity, cattr);
+ return mlir::LLVM::ConstantOp::create(rewriter, loc, ity, cattr);
}
/// Perform an extension or truncation as needed on an integer value. Lowering
@@ -80,9 +80,9 @@ mlir::Value ConvertFIRToLLVMPattern::integerCast(
return rewriter.createOrFold<mlir::LLVM::SExtOp>(loc, ty, val);
} else {
if (toSize < fromSize)
- return rewriter.create<mlir::LLVM::TruncOp>(loc, ty, val);
+ return mlir::LLVM::TruncOp::create(rewriter, loc, ty, val);
if (toSize > fromSize)
- return rewriter.create<mlir::LLVM::SExtOp>(loc, ty, val);
+ return mlir::LLVM::SExtOp::create(rewriter, loc, ty, val);
}
return val;
}
@@ -100,16 +100,16 @@ mlir::Value ConvertFIRToLLVMPattern::getValueFromBox(
mlir::ConversionPatternRewriter &rewriter, int boxValue) const {
if (mlir::isa<mlir::LLVM::LLVMPointerType>(box.getType())) {
auto pty = getLlvmPtrType(resultTy.getContext());
- auto p = rewriter.create<mlir::LLVM::GEPOp>(
+ auto p = mlir::LLVM::GEPOp::create(rewriter,
loc, pty, boxTy.llvm, box,
llvm::ArrayRef<mlir::LLVM::GEPArg>{0, boxValue});
auto fldTy = getBoxEleTy(boxTy.llvm, {boxValue});
- auto loadOp = rewriter.create<mlir::LLVM::LoadOp>(loc, fldTy, p);
+ auto loadOp = mlir::LLVM::LoadOp::create(rewriter, loc, fldTy, p);
auto castOp = integerCast(loc, rewriter, resultTy, loadOp);
attachTBAATag(loadOp, boxTy.fir, nullptr, p);
return castOp;
}
- return rewriter.create<mlir::LLVM::ExtractValueOp>(loc, box, boxValue);
+ return mlir::LLVM::ExtractValueOp::create(rewriter, loc, box, boxValue);
}
/// Method to construct code sequence to get the triple for dimension `dim`
@@ -147,7 +147,7 @@ mlir::Value ConvertFIRToLLVMPattern::loadDimFieldFromBox(
"in memory");
mlir::LLVM::GEPOp p = genGEP(loc, boxTy.llvm, rewriter, box, 0,
static_cast<int>(kDimsPosInBox), dim, off);
- auto loadOp = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
+ auto loadOp = mlir::LLVM::LoadOp::create(rewriter, loc, ty, p);
attachTBAATag(loadOp, boxTy.fir, nullptr, p);
return loadOp;
}
@@ -158,11 +158,11 @@ mlir::Value ConvertFIRToLLVMPattern::getDimFieldFromBox(
if (mlir::isa<mlir::LLVM::LLVMPointerType>(box.getType())) {
mlir::LLVM::GEPOp p = genGEP(loc, boxTy.llvm, rewriter, box, 0,
static_cast<int>(kDimsPosInBox), dim, off);
- auto loadOp = rewriter.create<mlir::LLVM::LoadOp>(loc, ty, p);
+ auto loadOp = mlir::LLVM::LoadOp::create(rewriter, loc, ty, p);
attachTBAATag(loadOp, boxTy.fir, nullptr, p);
return loadOp;
}
- return rewriter.create<mlir::LLVM::ExtractValueOp>(
+ return mlir::LLVM::ExtractValueOp::create(rewriter,
loc, box, llvm::ArrayRef<std::int64_t>{kDimsPosInBox, dim, off});
}
@@ -251,9 +251,9 @@ mlir::Value ConvertFIRToLLVMPattern::genBoxAttributeCheck(
getValueFromBox(loc, boxTy, box, attrTy, rewriter, kAttributePosInBox);
mlir::LLVM::ConstantOp attrMask = genConstantOffset(loc, rewriter, maskValue);
auto maskRes =
- rewriter.create<mlir::LLVM::AndOp>(loc, attrTy, attribute, attrMask);
+ mlir::LLVM::AndOp::create(rewriter, loc, attrTy, attribute, attrMask);
mlir::LLVM::ConstantOp c0 = genConstantOffset(loc, rewriter, 0);
- return rewriter.create<mlir::LLVM::ICmpOp>(loc, mlir::LLVM::ICmpPredicate::ne,
+ return mlir::LLVM::ICmpOp::create(rewriter, loc, mlir::LLVM::ICmpPredicate::ne,
maskRes, c0);
}
@@ -281,9 +281,9 @@ mlir::Value ConvertFIRToLLVMPattern::computeBoxSize(
firBoxType.getBoxTypeWithNewShape(1)))) &&
"descriptor layout requires adding padding for dim field");
mlir::Value sizePerDim = genConstantOffset(loc, rewriter, sizePerDimCst);
- mlir::Value dimsSize = rewriter.create<mlir::LLVM::MulOp>(
+ mlir::Value dimsSize = mlir::LLVM::MulOp::create(rewriter,
loc, sizePerDim.getType(), sizePerDim, rank);
- mlir::Value size = rewriter.create<mlir::LLVM::AddOp>(
+ mlir::Value size = mlir::LLVM::AddOp::create(rewriter,
loc, scalarBoxSize.getType(), scalarBoxSize, dimsSize);
return size;
}
@@ -324,7 +324,7 @@ mlir::Value ConvertFIRToLLVMPattern::genAllocaAndAddrCastWithType(
unsigned allocaAs = getAllocaAddressSpace(rewriter);
unsigned programAs = getProgramAddressSpace(rewriter);
- mlir::Value al = rewriter.create<mlir::LLVM::AllocaOp>(
+ mlir::Value al = mlir::LLVM::AllocaOp::create(rewriter,
loc, ::getLlvmPtrType(llvmObjectTy.getContext(), allocaAs), llvmObjectTy,
size, alignment);
@@ -334,7 +334,7 @@ mlir::Value ConvertFIRToLLVMPattern::genAllocaAndAddrCastWithType(
// the numeric value 5 (private), and the program address space is 0
// (generic).
if (allocaAs != programAs) {
- al = rewriter.create<mlir::LLVM::AddrSpaceCastOp>(
+ al = mlir::LLVM::AddrSpaceCastOp::create(rewriter,
loc, ::getLlvmPtrType(llvmObjectTy.getContext(), programAs), al);
}
diff --git a/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp b/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp
index d2cf85bedd54c..926c3e57d271f 100644
--- a/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp
+++ b/flang/lib/Optimizer/CodeGen/LowerRepackArrays.cpp
@@ -152,20 +152,20 @@ PackArrayConversion::matchAndRewrite(fir::PackArrayOp op,
// For now we have to always check if the box is present.
auto isPresent =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), box);
+ fir::IsPresentOp::create(builder, loc, builder.getI1Type(), box);
- fir::IfOp ifOp = builder.create<fir::IfOp>(loc, boxType, isPresent,
+ fir::IfOp ifOp = fir::IfOp::create(builder, loc, boxType, isPresent,
/*withElseRegion=*/true);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
// The box is present.
auto newBox = genRepackedBox(builder, loc, op);
if (mlir::failed(newBox))
return newBox;
- builder.create<fir::ResultOp>(loc, *newBox);
+ fir::ResultOp::create(builder, loc, *newBox);
// The box is not present. Return original box.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
- builder.create<fir::ResultOp>(loc, box);
+ fir::ResultOp::create(builder, loc, box);
rewriter.replaceOp(op, ifOp.getResult(0));
return mlir::success();
@@ -199,7 +199,7 @@ mlir::Value PackArrayConversion::allocateTempBuffer(
// We need to reset the CFI_attribute_allocatable before
// returning the temporary box to avoid any mishandling
// of the temporary box in Fortran runtime.
- base = builder.create<fir::BoxAddrOp>(loc, fir::boxMemRefType(tempBoxType),
+ base = fir::BoxAddrOp::create(builder, loc, fir::boxMemRefType(tempBoxType),
base);
ptrType = base.getType();
}
@@ -263,22 +263,22 @@ PackArrayConversion::genRepackedBox(fir::FirOpBuilder &builder,
// Create a temporay iff the original is not contigous and is not empty.
auto isNotContiguous = builder.genNot(
- loc, builder.create<fir::IsContiguousBoxOp>(loc, box, op.getInnermost()));
+ loc, fir::IsContiguousBoxOp::create(builder, loc, box, op.getInnermost()));
auto dataAddr =
- builder.create<fir::BoxAddrOp>(loc, fir::boxMemRefType(boxType), box);
+ fir::BoxAddrOp::create(builder, loc, fir::boxMemRefType(boxType), box);
auto isNotEmpty =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), dataAddr);
+ fir::IsPresentOp::create(builder, loc, builder.getI1Type(), dataAddr);
auto doPack =
- builder.create<mlir::arith::AndIOp>(loc, isNotContiguous, isNotEmpty);
+ mlir::arith::AndIOp::create(builder, loc, isNotContiguous, isNotEmpty);
fir::IfOp ifOp =
- builder.create<fir::IfOp>(loc, boxType, doPack, /*withElseRegion=*/true);
+ fir::IfOp::create(builder, loc, boxType, doPack, /*withElseRegion=*/true);
// Assume that the repacking is unlikely.
ifOp.setUnlikelyIfWeights();
// Return original box.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
- builder.create<fir::ResultOp>(loc, box);
+ fir::ResultOp::create(builder, loc, box);
// Create a new box.
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
@@ -308,7 +308,7 @@ PackArrayConversion::genRepackedBox(fir::FirOpBuilder &builder,
if (!op.getNoCopy())
fir::runtime::genShallowCopy(builder, loc, tempBox, box,
/*resultIsAllocated=*/true);
- builder.create<fir::ResultOp>(loc, tempBox);
+ fir::ResultOp::create(builder, loc, tempBox);
return ifOp.getResult(0);
}
@@ -330,15 +330,15 @@ UnpackArrayConversion::matchAndRewrite(fir::UnpackArrayOp op,
// For now we have to always check if the box is present.
auto isPresent =
- builder.create<fir::IsPresentOp>(loc, predicateType, originalBox);
+ fir::IsPresentOp::create(builder, loc, predicateType, originalBox);
builder.genIfThen(loc, isPresent).genThen([&]() {
mlir::Type addrType =
fir::HeapType::get(fir::extractSequenceType(tempBox.getType()));
mlir::Value tempAddr =
- builder.create<fir::BoxAddrOp>(loc, addrType, tempBox);
+ fir::BoxAddrOp::create(builder, loc, addrType, tempBox);
mlir::Value originalAddr =
- builder.create<fir::BoxAddrOp>(loc, addrType, originalBox);
+ fir::BoxAddrOp::create(builder, loc, addrType, originalBox);
auto isNotSame = builder.genPtrCompare(loc, mlir::arith::CmpIPredicate::ne,
tempAddr, originalAddr);
@@ -356,7 +356,7 @@ UnpackArrayConversion::matchAndRewrite(fir::UnpackArrayOp op,
// to the runtime that uses heap memory, even when the stack
// attribute is set on fir.pack_array.
if (!op.getStack() || !canAllocateTempOnStack(originalBox))
- builder.create<fir::FreeMemOp>(loc, tempAddr);
+ fir::FreeMemOp::create(builder, loc, tempAddr);
})
.getIfOp()
.setUnlikelyIfWeights();
diff --git a/flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp b/flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp
index b60ac11c7795a..a26f21e5be792 100644
--- a/flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp
+++ b/flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp
@@ -103,10 +103,10 @@ class EmboxConversion : public mlir::OpRewritePattern<fir::EmboxOp> {
auto idxTy = rewriter.getIndexType();
for (auto ext : seqTy.getShape()) {
auto iAttr = rewriter.getIndexAttr(ext);
- auto extVal = rewriter.create<mlir::arith::ConstantOp>(loc, idxTy, iAttr);
+ auto extVal = mlir::arith::ConstantOp::create(rewriter, loc, idxTy, iAttr);
shapeOpers.push_back(extVal);
}
- auto xbox = rewriter.create<fir::cg::XEmboxOp>(
+ auto xbox = fir::cg::XEmboxOp::create(rewriter,
loc, embox.getType(), embox.getMemref(), shapeOpers, mlir::ValueRange{},
mlir::ValueRange{}, mlir::ValueRange{}, mlir::ValueRange{},
embox.getTypeparams(), embox.getSourceBox(),
@@ -143,7 +143,7 @@ class EmboxConversion : public mlir::OpRewritePattern<fir::EmboxOp> {
substrOpers.assign(sliceOp.getSubstr().begin(),
sliceOp.getSubstr().end());
}
- auto xbox = rewriter.create<fir::cg::XEmboxOp>(
+ auto xbox = fir::cg::XEmboxOp::create(rewriter,
loc, embox.getType(), embox.getMemref(), shapeOpers, shiftOpers,
sliceOpers, subcompOpers, substrOpers, embox.getTypeparams(),
embox.getSourceBox(), embox.getAllocatorIdxAttr());
@@ -201,7 +201,7 @@ class ReboxConversion : public mlir::OpRewritePattern<fir::ReboxOp> {
sliceOp.getSubstr().end());
}
- auto xRebox = rewriter.create<fir::cg::XReboxOp>(
+ auto xRebox = fir::cg::XReboxOp::create(rewriter,
loc, rebox.getType(), rebox.getBox(), shapeOpers, shiftOpers,
sliceOpers, subcompOpers, substrOpers);
LLVM_DEBUG(llvm::dbgs()
@@ -259,7 +259,7 @@ class ArrayCoorConversion : public mlir::OpRewritePattern<fir::ArrayCoorOp> {
"Don't allow substring operations on array_coor. This "
"restriction may be lifted in the future.");
}
- auto xArrCoor = rewriter.create<fir::cg::XArrayCoorOp>(
+ auto xArrCoor = fir::cg::XArrayCoorOp::create(rewriter,
loc, arrCoor.getType(), arrCoor.getMemref(), shapeOpers, shiftOpers,
sliceOpers, subcompOpers, arrCoor.getIndices(),
arrCoor.getTypeparams());
@@ -301,7 +301,7 @@ class DeclareOpConversion : public mlir::OpRewritePattern<fir::DeclareOp> {
return mlir::failure();
}
// FIXME: Add FortranAttrs and CudaAttrs
- auto xDeclOp = rewriter.create<fir::cg::XDeclareOp>(
+ auto xDeclOp = fir::cg::XDeclareOp::create(rewriter,
loc, declareOp.getType(), declareOp.getMemref(), shapeOpers, shiftOpers,
declareOp.getTypeparams(), declareOp.getDummyScope(),
declareOp.getUniqName());
diff --git a/flang/lib/Optimizer/Dialect/FIRDialect.cpp b/flang/lib/Optimizer/Dialect/FIRDialect.cpp
index 4b1dadaac6728..12f1baf39be45 100644
--- a/flang/lib/Optimizer/Dialect/FIRDialect.cpp
+++ b/flang/lib/Optimizer/Dialect/FIRDialect.cpp
@@ -56,7 +56,7 @@ struct FIRInlinerInterface : public mlir::DialectInlinerInterface {
mlir::Value input,
mlir::Type resultType,
mlir::Location loc) const final {
- return builder.create<fir::ConvertOp>(loc, resultType, input);
+ return fir::ConvertOp::create(builder, loc, resultType, input);
}
};
} // namespace
diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp
index cf20d84cbbcdb..e8ef2f73b05ab 100644
--- a/flang/lib/Optimizer/Dialect/FIROps.cpp
+++ b/flang/lib/Optimizer/Dialect/FIROps.cpp
@@ -782,7 +782,7 @@ struct SimplifyArrayCoorOp : public mlir::OpRewritePattern<fir::ArrayCoorOp> {
return nullptr;
mlir::OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPoint(shapeShiftOp);
- return rewriter.create<fir::ShapeOp>(shapeShiftOp.getLoc(),
+ return fir::ShapeOp::create(rewriter, shapeShiftOp.getLoc(),
shapeShiftOp.getExtents());
}
@@ -797,19 +797,19 @@ struct SimplifyArrayCoorOp : public mlir::OpRewritePattern<fir::ArrayCoorOp> {
rewriter.setInsertionPoint(op);
mlir::Location loc = op->getLoc();
mlir::Type idxTy = rewriter.getIndexType();
- mlir::Value one = rewriter.create<mlir::arith::ConstantOp>(
+ mlir::Value one = mlir::arith::ConstantOp::create(rewriter,
loc, idxTy, rewriter.getIndexAttr(1));
rewriter.restoreInsertionPoint(savedIP);
auto nsw = mlir::arith::IntegerOverflowFlags::nsw;
IndicesVectorTy shiftedIndices;
for (auto [lb, idx] : llvm::zip(lbs, indices)) {
- mlir::Value extLb = rewriter.create<fir::ConvertOp>(loc, idxTy, lb);
- mlir::Value extIdx = rewriter.create<fir::ConvertOp>(loc, idxTy, idx);
+ mlir::Value extLb = fir::ConvertOp::create(rewriter, loc, idxTy, lb);
+ mlir::Value extIdx = fir::ConvertOp::create(rewriter, loc, idxTy, idx);
mlir::Value add =
- rewriter.create<mlir::arith::AddIOp>(loc, extIdx, extLb, nsw);
+ mlir::arith::AddIOp::create(rewriter, loc, extIdx, extLb, nsw);
mlir::Value sub =
- rewriter.create<mlir::arith::SubIOp>(loc, add, one, nsw);
+ mlir::arith::SubIOp::create(rewriter, loc, add, one, nsw);
shiftedIndices.push_back(sub);
}
@@ -4711,7 +4711,7 @@ mlir::func::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
return f;
mlir::OpBuilder modBuilder(module.getBodyRegion());
modBuilder.setInsertionPointToEnd(module.getBody());
- auto result = modBuilder.create<mlir::func::FuncOp>(loc, name, type, attrs);
+ auto result = mlir::func::FuncOp::create(modBuilder, loc, name, type, attrs);
result.setVisibility(mlir::SymbolTable::Visibility::Private);
return result;
}
@@ -4731,7 +4731,7 @@ fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
return g;
mlir::OpBuilder modBuilder(module.getBodyRegion());
- auto result = modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
+ auto result = fir::GlobalOp::create(modBuilder, loc, name, type, attrs);
result.setVisibility(mlir::SymbolTable::Visibility::Private);
return result;
}
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
index cb77aef74acd5..818e6ef1c27a2 100644
--- a/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
+++ b/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
@@ -201,13 +201,13 @@ mlir::Value hlfir::genExprShape(mlir::OpBuilder &builder,
for (std::int64_t extent : expr.getShape()) {
if (extent == hlfir::ExprType::getUnknownExtent())
return {};
- extents.emplace_back(builder.create<mlir::arith::ConstantOp>(
+ extents.emplace_back(mlir::arith::ConstantOp::create(builder,
loc, indexTy, builder.getIntegerAttr(indexTy, extent)));
}
fir::ShapeType shapeTy =
fir::ShapeType::get(builder.getContext(), expr.getRank());
- fir::ShapeOp shape = builder.create<fir::ShapeOp>(loc, shapeTy, extents);
+ fir::ShapeOp shape = fir::ShapeOp::create(builder, loc, shapeTy, extents);
return shape.getResult();
}
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
index df6ce12215d26..974a1120a5b1d 100644
--- a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
+++ b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
@@ -257,7 +257,7 @@ updateDeclaredInputTypeWithVolatility(mlir::Type inputType, mlir::Value memref,
llvm::TypeSwitch<mlir::Type>(inputType)
.Case<fir::ReferenceType, fir::BoxType, fir::ClassType>(updateType);
memref =
- builder.create<fir::VolatileCastOp>(memref.getLoc(), inputType, memref);
+ fir::VolatileCastOp::create(builder, memref.getLoc(), inputType, memref);
return std::make_pair(inputType, memref);
}
@@ -1293,7 +1293,7 @@ hlfir::MatmulOp::canonicalize(MatmulOp matmulOp,
if (isOtherwiseUnused(transposeOp)) {
mlir::Location loc = matmulOp.getLoc();
mlir::Type resultTy = matmulOp.getResult().getType();
- auto matmulTransposeOp = rewriter.create<hlfir::MatmulTransposeOp>(
+ auto matmulTransposeOp = hlfir::MatmulTransposeOp::create(rewriter,
loc, resultTy, transposeOp.getArray(), matmulOp.getRhs(),
matmulOp.getFastmathAttr());
@@ -2271,7 +2271,7 @@ hlfir::GetLengthOp::canonicalize(GetLengthOp getLength,
return mlir::failure();
mlir::Type indexTy = rewriter.getIndexType();
- auto cstLen = rewriter.create<mlir::arith::ConstantOp>(
+ auto cstLen = mlir::arith::ConstantOp::create(rewriter,
loc, indexTy, mlir::IntegerAttr::get(indexTy, charTy.getLen()));
rewriter.replaceOp(getLength, cstLen);
return mlir::success();
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
index 00ca6731c035b..2ea0a967d7425 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp
@@ -53,12 +53,12 @@ static mlir::Value packageBufferizedExpr(mlir::Location loc,
auto tupleType = mlir::TupleType::get(
builder.getContext(),
mlir::TypeRange{storage.getType(), mustFree.getType()});
- auto undef = builder.create<fir::UndefOp>(loc, tupleType);
- auto insert = builder.create<fir::InsertValueOp>(
+ auto undef = fir::UndefOp::create(builder, loc, tupleType);
+ auto insert = fir::InsertValueOp::create(builder,
loc, tupleType, undef, mustFree,
builder.getArrayAttr(
{builder.getIntegerAttr(builder.getIndexType(), 1)}));
- return builder.create<fir::InsertValueOp>(
+ return fir::InsertValueOp::create(builder,
loc, tupleType, insert, storage,
builder.getArrayAttr(
{builder.getIntegerAttr(builder.getIndexType(), 0)}));
@@ -117,7 +117,7 @@ createArrayTemp(mlir::Location loc, fir::FirOpBuilder &builder,
llvm::ArrayRef<mlir::Value> typeParams,
fir::FortranVariableFlagsAttr attrs) -> mlir::Value {
auto declareOp =
- builder.create<hlfir::DeclareOp>(loc, memref, name, shape, typeParams,
+ hlfir::DeclareOp::create(builder, loc, memref, name, shape, typeParams,
/*dummy_scope=*/nullptr, attrs);
return declareOp.getBase();
};
@@ -137,7 +137,7 @@ static mlir::Value copyInTempAndPackage(mlir::Location loc,
hlfir::Entity source) {
auto [temp, cleanup] = hlfir::createTempFromMold(loc, builder, source);
assert(!temp.isAllocatable() && "expect temp to already be allocated");
- builder.create<hlfir::AssignOp>(loc, source, temp, /*realloc=*/false,
+ hlfir::AssignOp::create(builder, loc, source, temp, /*realloc=*/false,
/*keep_lhs_length_if_realloc=*/false,
/*temporary_lhs=*/true);
return packageBufferizedExpr(loc, builder, temp, cleanup);
@@ -210,11 +210,11 @@ struct ApplyOpConversion : public mlir::OpConversionPattern<hlfir::ApplyOp> {
mlir::Location loc = apply->getLoc();
hlfir::Entity bufferizedExpr = getBufferizedExprStorage(adaptor.getExpr());
mlir::Type resultType = hlfir::getVariableElementType(bufferizedExpr);
- mlir::Value result = rewriter.create<hlfir::DesignateOp>(
+ mlir::Value result = hlfir::DesignateOp::create(rewriter,
loc, resultType, bufferizedExpr, adaptor.getIndices(),
adaptor.getTypeparams());
if (fir::isa_trivial(apply.getType())) {
- result = rewriter.create<fir::LoadOp>(loc, result);
+ result = fir::LoadOp::create(rewriter, loc, result);
} else {
fir::FirOpBuilder builder(rewriter, apply.getOperation());
result =
@@ -297,12 +297,12 @@ struct SetLengthOpConversion
llvm::SmallVector<mlir::Value, 1> lenParams{adaptor.getLength()};
auto alloca = builder.createTemporary(loc, charType, tmpName,
/*shape=*/{}, lenParams);
- auto declareOp = builder.create<hlfir::DeclareOp>(
+ auto declareOp = hlfir::DeclareOp::create(builder,
loc, alloca, tmpName, /*shape=*/mlir::Value{}, lenParams,
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
hlfir::Entity temp{declareOp.getBase()};
// Assign string value to the created temp.
- builder.create<hlfir::AssignOp>(loc, string, temp,
+ hlfir::AssignOp::create(builder, loc, string, temp,
/*realloc=*/false,
/*keep_lhs_length_if_realloc=*/false,
/*temporary_lhs=*/true);
@@ -445,7 +445,7 @@ struct AssociateOpConversion
!mlir::isa<fir::BaseBoxType>(assocType)) ||
((mlir::isa<fir::BoxCharType>(sourceVar.getType()) &&
!mlir::isa<fir::BoxCharType>(assocType)))) {
- sourceVar = builder.create<fir::BoxAddrOp>(loc, assocType, sourceVar);
+ sourceVar = fir::BoxAddrOp::create(builder, loc, assocType, sourceVar);
} else {
sourceVar = builder.createConvert(loc, assocType, sourceVar);
}
@@ -511,7 +511,7 @@ struct AssociateOpConversion
name = *associate.getUniqName();
auto temp =
builder.createTemporary(loc, bufferizedExpr.getType(), name, attrs);
- builder.create<fir::StoreOp>(loc, bufferizedExpr, temp);
+ fir::StoreOp::create(builder, loc, bufferizedExpr, temp);
mlir::Value mustFree = builder.createBool(loc, false);
replaceWith(temp, temp, mustFree);
return mlir::success();
@@ -544,10 +544,10 @@ static void genBufferDestruction(mlir::Location loc, fir::FirOpBuilder &builder,
if (mustFinalize && !mlir::isa<fir::BaseBoxType>(var.getType()))
fir::emitFatalError(loc, "non-finalizable variable");
- addr = builder.create<fir::BoxAddrOp>(loc, heapType, var);
+ addr = fir::BoxAddrOp::create(builder, loc, heapType, var);
} else {
if (!mlir::isa<fir::HeapType>(var.getType()))
- addr = builder.create<fir::ConvertOp>(loc, heapType, var);
+ addr = fir::ConvertOp::create(builder, loc, heapType, var);
if (mustFinalize || deallocComponents) {
// Embox the raw pointer using proper shape and type params
@@ -577,7 +577,7 @@ static void genBufferDestruction(mlir::Location loc, fir::FirOpBuilder &builder,
fir::runtime::genDerivedTypeDestroyWithoutFinalization(builder, loc, var);
if (doFree)
- builder.create<fir::FreeMemOp>(loc, addr);
+ fir::FreeMemOp::create(builder, loc, addr);
};
bool deallocComponents = hlfir::mayHaveAllocatableComponent(var.getType());
@@ -657,7 +657,7 @@ struct NoReassocOpConversion
fir::FirOpBuilder builder(rewriter, noreassoc.getOperation());
mlir::Value bufferizedExpr = getBufferizedExprStorage(adaptor.getVal());
mlir::Value result =
- builder.create<hlfir::NoReassocOp>(loc, bufferizedExpr);
+ hlfir::NoReassocOp::create(builder, loc, bufferizedExpr);
if (!fir::isa_trivial(bufferizedExpr.getType())) {
// NoReassocOp should not be needed on the mustFree path.
@@ -775,10 +775,10 @@ struct ElementalOpConversion
if (asExpr && asExpr.isMove() && mlir::isa<fir::RecordType>(elemType) &&
hlfir::mayHaveAllocatableComponent(elemType) &&
wasCreatedInCurrentBlock(elementValue, builder)) {
- auto load = builder.create<fir::LoadOp>(loc, asExpr.getVar());
- builder.create<fir::StoreOp>(loc, load, tempElement);
+ auto load = fir::LoadOp::create(builder, loc, asExpr.getVar());
+ fir::StoreOp::create(builder, loc, load, tempElement);
} else {
- builder.create<hlfir::AssignOp>(loc, elementValue, tempElement,
+ hlfir::AssignOp::create(builder, loc, elementValue, tempElement,
/*realloc=*/false,
/*keep_lhs_length_if_realloc=*/false,
/*temporary_lhs=*/true);
@@ -792,7 +792,7 @@ struct ElementalOpConversion
// loop, this will ensure the buffer properly deallocated.
if (mlir::isa<hlfir::ExprType>(elementValue.getType()) &&
wasCreatedInCurrentBlock(elementValue, builder))
- builder.create<hlfir::DestroyOp>(loc, elementValue);
+ hlfir::DestroyOp::create(builder, loc, elementValue);
}
builder.restoreInsertionPoint(insPt);
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp
index 33f687db08f9a..74ad958d9ed8a 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp
@@ -82,8 +82,8 @@ class AssignOpConversion : public mlir::OpRewritePattern<hlfir::AssignOp> {
rhsType = fir::LogicalType::get(builder.getContext(), 4);
rhsVal = builder.createConvert(loc, rhsType, rhsVal);
}
- mlir::Value temp = builder.create<fir::AllocaOp>(loc, rhsType);
- builder.create<fir::StoreOp>(loc, rhsVal, temp);
+ mlir::Value temp = fir::AllocaOp::create(builder, loc, rhsType);
+ fir::StoreOp::create(builder, loc, rhsVal, temp);
rhsExv = temp;
}
return fir::getBase(builder.createBox(loc, rhsExv));
@@ -136,7 +136,7 @@ class AssignOpConversion : public mlir::OpRewritePattern<hlfir::AssignOp> {
// reallocate and modify "toMutableBox" even if it is taking it by
// reference.
auto toMutableBox = builder.createTemporary(loc, to.getType());
- builder.create<fir::StoreOp>(loc, to, toMutableBox);
+ fir::StoreOp::create(builder, loc, to, toMutableBox);
if (assignOp.isTemporaryLHS())
fir::runtime::genAssignTemporary(builder, loc, toMutableBox, from);
else
@@ -182,7 +182,7 @@ class CopyInOpConversion : public mlir::OpRewritePattern<hlfir::CopyInOp> {
.genIfOp(loc, {resultAddrType}, isContiguous,
/*withElseRegion=*/true)
.genThen(
- [&]() { builder.create<fir::ResultOp>(loc, inputVariable); })
+ [&]() { fir::ResultOp::create(builder, loc, inputVariable); })
.genElse([&] {
// Create temporary on the heap. Note that the runtime is used and
// that is desired: since the data copy happens under a runtime
@@ -191,17 +191,17 @@ class CopyInOpConversion : public mlir::OpRewritePattern<hlfir::CopyInOp> {
// compilation time on these loops.
mlir::Value temp = copyInOp.getTempBox();
fir::runtime::genCopyInAssign(builder, loc, temp, inputVariable);
- mlir::Value copy = builder.create<fir::LoadOp>(loc, temp);
+ mlir::Value copy = fir::LoadOp::create(builder, loc, temp);
// Get rid of allocatable flag in the fir.box.
if (mlir::cast<fir::BaseBoxType>(resultAddrType).isAssumedRank())
- copy = builder.create<fir::ReboxAssumedRankOp>(
+ copy = fir::ReboxAssumedRankOp::create(builder,
loc, resultAddrType, copy,
fir::LowerBoundModifierAttribute::Preserve);
else
- copy = builder.create<fir::ReboxOp>(loc, resultAddrType, copy,
+ copy = fir::ReboxOp::create(builder, loc, resultAddrType, copy,
/*shape=*/mlir::Value{},
/*slice=*/mlir::Value{});
- builder.create<fir::ResultOp>(loc, copy);
+ fir::ResultOp::create(builder, loc, copy);
})
.getResults()[0];
return {addr, builder.genNot(loc, isContiguous)};
@@ -218,13 +218,13 @@ class CopyInOpConversion : public mlir::OpRewritePattern<hlfir::CopyInOp> {
/*withElseRegion=*/true)
.genThen([&]() {
CopyInResult res = genNonOptionalCopyIn(loc, builder, copyInOp);
- builder.create<fir::ResultOp>(
+ fir::ResultOp::create(builder,
loc, mlir::ValueRange{res.addr, res.wasCopied});
})
.genElse([&] {
mlir::Value absent =
- builder.create<fir::AbsentOp>(loc, resultAddrType);
- builder.create<fir::ResultOp>(
+ fir::AbsentOp::create(builder, loc, resultAddrType);
+ fir::ResultOp::create(builder,
loc, mlir::ValueRange{absent, isPresent});
})
.getResults();
@@ -269,12 +269,12 @@ class CopyOutOpConversion : public mlir::OpRewritePattern<hlfir::CopyOutOp> {
// CopyOutAssign() guarantees that there will be no finalization for
// the LHS even if it is of a derived type with finalization.
varMutableBox = builder.createTemporary(loc, var.getType());
- builder.create<fir::StoreOp>(loc, var, varMutableBox);
+ fir::StoreOp::create(builder, loc, var, varMutableBox);
} else {
// Even when there is no need to copy back the data (e.g., the dummy
// argument was intent(in), CopyOutAssign is called to
// destroy/deallocate the temporary.
- varMutableBox = builder.create<fir::ZeroOp>(loc, temp.getType());
+ varMutableBox = fir::ZeroOp::create(builder, loc, temp.getType());
}
fir::runtime::genCopyOutAssign(builder, loc, varMutableBox,
copyOutOp.getTemp());
@@ -302,7 +302,7 @@ class DeclareOpConversion : public mlir::OpRewritePattern<hlfir::DeclareOp> {
fir::FortranVariableFlagsAttr::get(rewriter.getContext(), *attrs);
if (auto attr = declareOp.getDataAttr())
dataAttr = cuf::DataAttributeAttr::get(rewriter.getContext(), *attr);
- auto firDeclareOp = rewriter.create<fir::DeclareOp>(
+ auto firDeclareOp = fir::DeclareOp::create(rewriter,
loc, memref.getType(), memref, declareOp.getShape(),
declareOp.getTypeparams(), declareOp.getDummyScope(),
declareOp.getUniqName(), fortranAttrs, dataAttr);
@@ -328,13 +328,13 @@ class DeclareOpConversion : public mlir::OpRewritePattern<hlfir::DeclareOp> {
mlir::dyn_cast<fir::BaseBoxType>(firBase.getType())) {
// Rebox so that lower bounds and attributes are correct.
if (baseBoxType.isAssumedRank())
- return builder.create<fir::ReboxAssumedRankOp>(
+ return fir::ReboxAssumedRankOp::create(builder,
loc, hlfirBaseType, firBase,
fir::LowerBoundModifierAttribute::SetToOnes);
if (!fir::extractSequenceType(baseBoxType.getEleTy()) &&
baseBoxType == hlfirBaseType)
return firBase;
- return builder.create<fir::ReboxOp>(loc, hlfirBaseType, firBase,
+ return fir::ReboxOp::create(builder, loc, hlfirBaseType, firBase,
declareOp.getShape(),
/*slice=*/mlir::Value{});
} else {
@@ -344,7 +344,7 @@ class DeclareOpConversion : public mlir::OpRewritePattern<hlfir::DeclareOp> {
if (!maybeCharType || maybeCharType.hasDynamicLen())
typeParams.append(declareOp.getTypeparams().begin(),
declareOp.getTypeparams().end());
- return builder.create<fir::EmboxOp>(
+ return fir::EmboxOp::create(builder,
loc, hlfirBaseType, firBase, declareOp.getShape(),
/*slice=*/mlir::Value{}, typeParams);
}
@@ -368,24 +368,24 @@ class DeclareOpConversion : public mlir::OpRewritePattern<hlfir::DeclareOp> {
// the entity is absent so that later fir.is_present on the hlfir base
// are valid.
mlir::Value isPresent =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), firBase);
+ fir::IsPresentOp::create(builder, loc, builder.getI1Type(), firBase);
hlfirBase = builder
.genIfOp(loc, {hlfirBaseType}, isPresent,
/*withElseRegion=*/true)
.genThen([&] {
- builder.create<fir::ResultOp>(loc, genHlfirBox());
+ fir::ResultOp::create(builder, loc, genHlfirBox());
})
.genElse([&]() {
mlir::Value absent =
- builder.create<fir::AbsentOp>(loc, hlfirBaseType);
- builder.create<fir::ResultOp>(loc, absent);
+ fir::AbsentOp::create(builder, loc, hlfirBaseType);
+ fir::ResultOp::create(builder, loc, absent);
})
.getResults()[0];
}
} else if (mlir::isa<fir::BoxCharType>(hlfirBaseType)) {
assert(declareOp.getTypeparams().size() == 1 &&
"must contain character length");
- hlfirBase = rewriter.create<fir::EmboxCharOp>(
+ hlfirBase = fir::EmboxCharOp::create(rewriter,
loc, hlfirBaseType, firBase, declareOp.getTypeparams()[0]);
} else {
if (hlfirBaseType != firBase.getType()) {
@@ -426,7 +426,7 @@ class DesignateOpConversion
const bool isVolatile = fir::isa_volatile_type(originalDesignateType);
mlir::Type arrayCoorType = fir::ReferenceType::get(baseEleTy, isVolatile);
- base = builder.create<fir::ArrayCoorOp>(
+ base = fir::ArrayCoorOp::create(builder,
loc, arrayCoorType, base, shape,
/*slice=*/mlir::Value{}, firstElementIndices, firBaseTypeParameters);
return base;
@@ -461,7 +461,7 @@ class DesignateOpConversion
mlir::Type baseRecordType = baseEntity.getFortranElementType();
if (fir::isRecordWithTypeParameters(baseRecordType))
TODO(loc, "hlfir.designate with a parametrized derived type base");
- fieldIndex = builder.create<fir::FieldIndexOp>(
+ fieldIndex = fir::FieldIndexOp::create(builder,
loc, fir::FieldType::get(builder.getContext()),
designate.getComponent().value(), baseRecordType,
/*typeParams=*/mlir::ValueRange{});
@@ -475,7 +475,7 @@ class DesignateOpConversion
designate.getComponent().value());
mlir::Type coorTy = fir::ReferenceType::get(componentType, isVolatile);
- base = builder.create<fir::CoordinateOp>(loc, coorTy, base, fieldIndex);
+ base = fir::CoordinateOp::create(builder, loc, coorTy, base, fieldIndex);
if (mlir::isa<fir::BaseBoxType>(componentType)) {
auto variableInterface = mlir::cast<fir::FortranVariableOpInterface>(
designate.getOperation());
@@ -532,12 +532,12 @@ class DesignateOpConversion
mlir::Value iIdx = builder.createConvert(loc, idxTy, i);
mlir::Value lbIdx = builder.createConvert(loc, idxTy, lb);
sliceFields.emplace_back(
- builder.create<mlir::arith::SubIOp>(loc, iIdx, lbIdx));
+ mlir::arith::SubIOp::create(builder, loc, iIdx, lbIdx));
}
}
} else if (!isScalarDesignator) {
// Otherwise, this is an array section with triplets.
- auto undef = builder.create<fir::UndefOp>(loc, idxTy);
+ auto undef = fir::UndefOp::create(builder, loc, idxTy);
unsigned i = 0;
for (auto isTriplet : designate.getIsTriplet()) {
triples.push_back(subscripts[i++]);
@@ -558,7 +558,7 @@ class DesignateOpConversion
mlir::Value one = builder.createIntegerConstant(loc, idxTy, 1);
substring[0] = builder.createConvert(loc, idxTy, substring[0]);
substring[0] =
- builder.create<mlir::arith::SubIOp>(loc, substring[0], one);
+ mlir::arith::SubIOp::create(builder, loc, substring[0], one);
substring.push_back(designate.getTypeparams()[0]);
}
if (designate.getComplexPart()) {
@@ -570,7 +570,7 @@ class DesignateOpConversion
mlir::Value slice;
if (!triples.empty())
slice =
- builder.create<fir::SliceOp>(loc, triples, sliceFields, substring);
+ fir::SliceOp::create(builder, loc, triples, sliceFields, substring);
else
assert(sliceFields.empty() && substring.empty());
@@ -580,10 +580,10 @@ class DesignateOpConversion
mlir::Value resultBox;
if (mlir::isa<fir::BaseBoxType>(base.getType())) {
resultBox =
- builder.create<fir::ReboxOp>(loc, resultType, base, shape, slice);
+ fir::ReboxOp::create(builder, loc, resultType, base, shape, slice);
} else {
resultBox =
- builder.create<fir::EmboxOp>(loc, resultType, base, shape, slice,
+ fir::EmboxOp::create(builder, loc, resultType, base, shape, slice,
firBaseTypeParameters, sourceBox);
}
rewriter.replaceOp(designate, resultBox);
@@ -623,14 +623,14 @@ class DesignateOpConversion
*designate.getComplexPart());
auto coorTy = fir::ReferenceType::get(resultEleTy, isVolatile);
- base = builder.create<fir::CoordinateOp>(loc, coorTy, base, index);
+ base = fir::CoordinateOp::create(builder, loc, coorTy, base, index);
}
// Cast/embox the computed scalar address if needed.
if (mlir::isa<fir::BoxCharType>(designateResultType)) {
assert(designate.getTypeparams().size() == 1 &&
"must have character length");
- auto emboxChar = builder.create<fir::EmboxCharOp>(
+ auto emboxChar = fir::EmboxCharOp::create(builder,
loc, designateResultType, base, designate.getTypeparams()[0]);
rewriter.replaceOp(designate, emboxChar.getResult());
@@ -679,7 +679,7 @@ class ParentComponentOpConversion
// and the output will be monomorphic, the base address can be extracted
// from the fir.class.
if (mlir::isa<fir::BaseBoxType>(baseAddr.getType()))
- baseAddr = rewriter.create<fir::BoxAddrOp>(loc, baseAddr);
+ baseAddr = fir::BoxAddrOp::create(rewriter, loc, baseAddr);
rewriter.replaceOpWithNewOp<fir::ConvertOp>(parentComponent, resultType,
baseAddr);
return mlir::success();
@@ -697,7 +697,7 @@ class ParentComponentOpConversion
fir::BoxType::get(base.getElementOrSequenceType());
assert(!base.hasLengthParameters() &&
"base must be a box if it has any type parameters");
- baseAddr = rewriter.create<fir::EmboxOp>(
+ baseAddr = fir::EmboxOp::create(rewriter,
loc, baseBoxType, baseAddr, parentComponent.getShape(),
/*slice=*/mlir::Value{}, /*typeParams=*/mlir::ValueRange{});
}
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRAssign.cpp b/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRAssign.cpp
index 6c4a07be52a48..86d39749df93d 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRAssign.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRAssign.cpp
@@ -126,7 +126,7 @@ class InlineHLFIRAssignConversion
rhsArrayElement = hlfir::loadTrivialScalar(loc, builder, rhsArrayElement);
auto lhsArrayElement =
hlfir::getElementAt(loc, builder, lhs, loopNest.oneBasedIndices);
- builder.create<hlfir::AssignOp>(loc, rhsArrayElement, lhsArrayElement);
+ hlfir::AssignOp::create(builder, loc, rhsArrayElement, lhsArrayElement);
rewriter.eraseOp(assign);
return mlir::success();
}
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRCopyIn.cpp b/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRCopyIn.cpp
index 7e8acc515ee26..8c4ce934b809a 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRCopyIn.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/InlineHLFIRCopyIn.cpp
@@ -82,7 +82,7 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
hlfir::getFortranElementOrSequenceType(inputVariable.getType());
fir::BoxType resultBoxType = fir::BoxType::get(sequenceType);
mlir::Value isContiguous =
- builder.create<fir::IsContiguousBoxOp>(loc, inputVariable);
+ fir::IsContiguousBoxOp::create(builder, loc, inputVariable);
mlir::Operation::result_range results =
builder
.genIfOp(loc, {resultBoxType, builder.getI1Type()}, isContiguous,
@@ -90,11 +90,11 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
.genThen([&]() {
mlir::Value result = inputVariable;
if (fir::isPointerType(inputVariable.getType())) {
- result = builder.create<fir::ReboxOp>(
+ result = fir::ReboxOp::create(builder,
loc, resultBoxType, inputVariable, mlir::Value{},
mlir::Value{});
}
- builder.create<fir::ResultOp>(
+ fir::ResultOp::create(builder,
loc, mlir::ValueRange{result, builder.createBool(loc, false)});
})
.genElse([&] {
@@ -106,7 +106,7 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
mlir::Value alloc = builder.createHeapTemporary(
loc, sequenceType, tmpName, extents, lenParams);
- auto declareOp = builder.create<hlfir::DeclareOp>(
+ auto declareOp = hlfir::DeclareOp::create(builder,
loc, alloc, tmpName, shape, lenParams,
/*dummy_scope=*/nullptr);
hlfir::Entity temp{declareOp.getBase()};
@@ -120,7 +120,7 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
elem = hlfir::loadTrivialScalar(loc, builder, elem);
hlfir::Entity tempElem = hlfir::getElementAt(
loc, builder, temp, loopNest.oneBasedIndices);
- builder.create<hlfir::AssignOp>(loc, elem, tempElem);
+ hlfir::AssignOp::create(builder, loc, elem, tempElem);
builder.setInsertionPointAfter(loopNest.outerOp);
mlir::Value result;
@@ -132,11 +132,11 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
fir::ReferenceType refTy =
fir::ReferenceType::get(temp.getElementOrSequenceType());
mlir::Value refVal = builder.createConvert(loc, refTy, temp);
- result = builder.create<fir::EmboxOp>(loc, resultBoxType, refVal,
+ result = fir::EmboxOp::create(builder, loc, resultBoxType, refVal,
shape);
}
- builder.create<fir::ResultOp>(
+ fir::ResultOp::create(builder,
loc, mlir::ValueRange{result, builder.createBool(loc, true)});
})
.getResults();
@@ -145,8 +145,8 @@ InlineCopyInConversion::matchAndRewrite(hlfir::CopyInOp copyIn,
mlir::OpResult needsCleanup = results[1];
// Prepare the corresponding copyOut to free the temporary if it is required
- auto alloca = builder.create<fir::AllocaOp>(loc, resultBox.getType());
- auto store = builder.create<fir::StoreOp>(loc, resultBox, alloca);
+ auto alloca = fir::AllocaOp::create(builder, loc, resultBox.getType());
+ auto store = fir::StoreOp::create(builder, loc, resultBox, alloca);
rewriter.startOpModification(copyOut);
copyOut->setOperand(0, store.getMemref());
copyOut->setOperand(1, needsCleanup);
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp
index 31e5bc1193e22..1c7c8624031c3 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIRIntrinsics.cpp
@@ -169,7 +169,7 @@ class HlfirIntrinsicConversion : public mlir::OpRewritePattern<OP> {
}
if (resultEntity->isVariable()) {
- hlfir::AsExprOp asExpr = builder.create<hlfir::AsExprOp>(
+ hlfir::AsExprOp asExpr = hlfir::AsExprOp::create(builder,
loc, *resultEntity, builder.createBool(loc, mustBeFreed));
resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
}
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
index c5cf01ed98357..3e2b0be34a83f 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
@@ -377,7 +377,7 @@ void OrderedAssignmentRewriter::pre(hlfir::ForallOp forallOp) {
} else {
step = generateYieldedScalarValue(forallOp.getStepRegion(), idxTy);
}
- auto doLoop = builder.create<fir::DoLoopOp>(loc, lb, ub, step);
+ auto doLoop = fir::DoLoopOp::create(builder, loc, lb, ub, step);
builder.setInsertionPointToStart(doLoop.getBody());
mlir::Value oldIndex = forallOp.getForallIndexValue();
mlir::Value newIndex =
@@ -405,7 +405,7 @@ void OrderedAssignmentRewriter::pre(hlfir::ForallMaskOp forallMaskOp) {
mlir::Location loc = forallMaskOp.getLoc();
mlir::Value mask = generateYieldedScalarValue(forallMaskOp.getMaskRegion(),
builder.getI1Type());
- auto ifOp = builder.create<fir::IfOp>(loc, mlir::TypeRange{}, mask, false);
+ auto ifOp = fir::IfOp::create(builder, loc, mlir::TypeRange{}, mask, false);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
constructStack.push_back(ifOp);
}
@@ -431,11 +431,11 @@ convertToMoldType(mlir::Location loc, fir::FirOpBuilder &builder,
if (input.isVariable() && mold.isValue()) {
if (fir::isa_trivial(mold.getType())) {
// fir.ref<T> to T.
- mlir::Value load = builder.create<fir::LoadOp>(loc, input);
+ mlir::Value load = fir::LoadOp::create(builder, loc, input);
return hlfir::Entity{builder.createConvert(loc, mold.getType(), load)};
}
// fir.ref<T> to hlfir.expr<T>.
- mlir::Value asExpr = builder.create<hlfir::AsExprOp>(loc, input);
+ mlir::Value asExpr = hlfir::AsExprOp::create(builder, loc, input);
if (asExpr.getType() != mold.getType())
TODO(loc, "hlfir.expr conversion");
cleanups.emplace_back([=]() { b->create<hlfir::DestroyOp>(loc, asExpr); });
@@ -517,7 +517,7 @@ void OrderedAssignmentRewriter::pre(hlfir::RegionAssignOp regionAssignOp) {
} else {
// TODO: preserve allocatable assignment aspects for forall once
// they are conveyed in hlfir.region_assign.
- builder.create<hlfir::AssignOp>(loc, rhsEntity, lhsEntity);
+ hlfir::AssignOp::create(builder, loc, rhsEntity, lhsEntity);
}
generateCleanupIfAny(loweredLhs.elementalCleanup);
if (loweredLhs.vectorSubscriptLoopNest)
@@ -530,7 +530,7 @@ void OrderedAssignmentRewriter::generateMaskIfOp(mlir::Value cdt) {
mlir::Location loc = cdt.getLoc();
cdt = hlfir::loadTrivialScalar(loc, builder, hlfir::Entity{cdt});
cdt = builder.createConvert(loc, builder.getI1Type(), cdt);
- auto ifOp = builder.create<fir::IfOp>(cdt.getLoc(), mlir::TypeRange{}, cdt,
+ auto ifOp = fir::IfOp::create(builder, cdt.getLoc(), mlir::TypeRange{}, cdt,
/*withElseRegion=*/false);
constructStack.push_back(ifOp.getOperation());
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
@@ -604,7 +604,7 @@ void OrderedAssignmentRewriter::enterElsewhere(hlfir::ElseWhereOp elseWhereOp) {
if (ifOp.getElseRegion().empty()) {
mlir::Location loc = elseWhereOp.getLoc();
builder.createBlock(&ifOp.getElseRegion());
- auto end = builder.create<fir::ResultOp>(loc);
+ auto end = fir::ResultOp::create(builder, loc);
builder.setInsertionPoint(end);
} else {
builder.setInsertionPoint(&ifOp.getElseRegion().back().back());
@@ -1150,7 +1150,7 @@ computeLoopNestIterationNumber(mlir::Location loc, fir::FirOpBuilder &builder,
if (!loopExtent)
loopExtent = extent;
else
- loopExtent = builder.create<mlir::arith::MulIOp>(loc, loopExtent, extent);
+ loopExtent = mlir::arith::MulIOp::create(builder, loc, loopExtent, extent);
}
assert(loopExtent && "loopNest must not be empty");
return loopExtent;
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/OptimizedBufferization.cpp b/flang/lib/Optimizer/HLFIR/Transforms/OptimizedBufferization.cpp
index abcbf145410ab..14dd36b2cb741 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/OptimizedBufferization.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/OptimizedBufferization.cpp
@@ -727,7 +727,7 @@ llvm::LogicalResult ElementalAssignBufferization::matchAndRewrite(
// Assign the element value to the array element for this iteration.
auto arrayElement =
hlfir::getElementAt(loc, builder, lhs, loopNest.oneBasedIndices);
- builder.create<hlfir::AssignOp>(
+ hlfir::AssignOp::create(builder,
loc, elementValue, arrayElement, /*realloc=*/false,
/*keep_lhs_length_if_realloc=*/false, match->assign.getTemporaryLhs());
@@ -793,7 +793,7 @@ llvm::LogicalResult BroadcastAssignBufferization::matchAndRewrite(
// optimized.
mlir::Value n = extents[0];
for (size_t i = 1; i < extents.size(); ++i)
- n = builder.create<mlir::arith::MulIOp>(loc, n, extents[i]);
+ n = mlir::arith::MulIOp::create(builder, loc, n, extents[i]);
llvm::SmallVector<mlir::Value> flatExtents = {n};
mlir::Type flatArrayType;
@@ -801,7 +801,7 @@ llvm::LogicalResult BroadcastAssignBufferization::matchAndRewrite(
if (mlir::isa<fir::BoxType>(lhs.getType())) {
shape = builder.genShape(loc, flatExtents);
flatArrayType = fir::BoxType::get(fir::SequenceType::get(eleTy, 1));
- flatArray = builder.create<fir::ReboxOp>(loc, flatArrayType, flatArray,
+ flatArray = fir::ReboxOp::create(builder, loc, flatArrayType, flatArray,
shape, /*slice=*/mlir::Value{});
} else {
// Array references must have fixed shape, when used in assignments.
@@ -822,9 +822,9 @@ llvm::LogicalResult BroadcastAssignBufferization::matchAndRewrite(
builder.setInsertionPointToStart(loopNest.body);
mlir::Value arrayElement =
- builder.create<hlfir::DesignateOp>(loc, fir::ReferenceType::get(eleTy),
+ hlfir::DesignateOp::create(builder, loc, fir::ReferenceType::get(eleTy),
flatArray, loopNest.oneBasedIndices);
- builder.create<hlfir::AssignOp>(loc, rhs, arrayElement);
+ hlfir::AssignOp::create(builder, loc, rhs, arrayElement);
} else {
hlfir::LoopNest loopNest =
hlfir::genLoopNest(loc, builder, extents, /*isUnordered=*/true,
@@ -832,7 +832,7 @@ llvm::LogicalResult BroadcastAssignBufferization::matchAndRewrite(
builder.setInsertionPointToStart(loopNest.body);
auto arrayElement =
hlfir::getElementAt(loc, builder, lhs, loopNest.oneBasedIndices);
- builder.create<hlfir::AssignOp>(loc, rhs, arrayElement);
+ hlfir::AssignOp::create(builder, loc, rhs, arrayElement);
}
rewriter.eraseOp(assign);
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp b/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp
index 79582390d1294..0b461d6ea73ef 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/SimplifyHLFIRIntrinsics.cpp
@@ -60,22 +60,22 @@ class ProductFactory {
v2 = castToProductType(v2, resultType);
mlir::Value result;
if (mlir::isa<mlir::FloatType>(resultType)) {
- result = builder.create<mlir::arith::AddFOp>(
- loc, acc, builder.create<mlir::arith::MulFOp>(loc, v1, v2));
+ result = mlir::arith::AddFOp::create(builder,
+ loc, acc, mlir::arith::MulFOp::create(builder, loc, v1, v2));
} else if (mlir::isa<mlir::ComplexType>(resultType)) {
if constexpr (CONJ)
result = fir::IntrinsicLibrary{builder, loc}.genConjg(resultType, v1);
else
result = v1;
- result = builder.create<fir::AddcOp>(
- loc, acc, builder.create<fir::MulcOp>(loc, result, v2));
+ result = fir::AddcOp::create(builder,
+ loc, acc, fir::MulcOp::create(builder, loc, result, v2));
} else if (mlir::isa<mlir::IntegerType>(resultType)) {
- result = builder.create<mlir::arith::AddIOp>(
- loc, acc, builder.create<mlir::arith::MulIOp>(loc, v1, v2));
+ result = mlir::arith::AddIOp::create(builder,
+ loc, acc, mlir::arith::MulIOp::create(builder, loc, v1, v2));
} else if (mlir::isa<fir::LogicalType>(resultType)) {
- result = builder.create<mlir::arith::OrIOp>(
- loc, acc, builder.create<mlir::arith::AndIOp>(loc, v1, v2));
+ result = mlir::arith::OrIOp::create(builder,
+ loc, acc, mlir::arith::AndIOp::create(builder, loc, v1, v2));
} else {
llvm_unreachable("unsupported type");
}
@@ -168,7 +168,7 @@ class TransposeAsElementalConversion
// transpose indices
assert(inExtents.size() == 2 && "checked in TransposeOp::validate");
- return builder.create<fir::ShapeOp>(
+ return fir::ShapeOp::create(builder,
loc, mlir::ValueRange{inExtents[1], inExtents[0]});
}
};
@@ -385,19 +385,19 @@ genMinMaxComparison(mlir::Location loc, fir::FirOpBuilder &builder,
// is not NaN. A OGL/OLT condition will usually work for this unless all
// the values are Nan or Inf. This follows the same logic as
// NumericCompare for Minloc/Maxloc in extrema.cpp.
- mlir::Value cmp = builder.create<mlir::arith::CmpFOp>(
+ mlir::Value cmp = mlir::arith::CmpFOp::create(builder,
loc,
IS_MAX ? mlir::arith::CmpFPredicate::OGT
: mlir::arith::CmpFPredicate::OLT,
elem, reduction);
- mlir::Value cmpNan = builder.create<mlir::arith::CmpFOp>(
+ mlir::Value cmpNan = mlir::arith::CmpFOp::create(builder,
loc, mlir::arith::CmpFPredicate::UNE, reduction, reduction);
- mlir::Value cmpNan2 = builder.create<mlir::arith::CmpFOp>(
+ mlir::Value cmpNan2 = mlir::arith::CmpFOp::create(builder,
loc, mlir::arith::CmpFPredicate::OEQ, elem, elem);
- cmpNan = builder.create<mlir::arith::AndIOp>(loc, cmpNan, cmpNan2);
- return builder.create<mlir::arith::OrIOp>(loc, cmp, cmpNan);
+ cmpNan = mlir::arith::AndIOp::create(builder, loc, cmpNan, cmpNan2);
+ return mlir::arith::OrIOp::create(builder, loc, cmp, cmpNan);
} else if (mlir::isa<mlir::IntegerType>(reduction.getType())) {
- return builder.create<mlir::arith::CmpIOp>(
+ return mlir::arith::CmpIOp::create(builder,
loc,
IS_MAX ? mlir::arith::CmpIPredicate::sgt
: mlir::arith::CmpIPredicate::slt,
@@ -415,9 +415,9 @@ genIsNotEmptyArrayExtents(mlir::Location loc, fir::FirOpBuilder &builder,
for (auto extent : extents) {
mlir::Value zero =
fir::factory::createZeroValue(builder, loc, extent.getType());
- mlir::Value cmp = builder.create<mlir::arith::CmpIOp>(
+ mlir::Value cmp = mlir::arith::CmpIOp::create(builder,
loc, mlir::arith::CmpIPredicate::ne, extent, zero);
- isNotEmpty = builder.create<mlir::arith::AndIOp>(loc, isNotEmpty, cmp);
+ isNotEmpty = mlir::arith::AndIOp::create(builder, loc, isNotEmpty, cmp);
}
return isNotEmpty;
}
@@ -581,7 +581,7 @@ MinMaxlocAsElementalConverter<T>::genReductionInitValues(
llvm::SmallVector<mlir::Type> ifTypes(getNumCoors(),
getResultElementType());
ifTypes.push_back(getSourceElementType());
- ifOp = builder.create<fir::IfOp>(loc, ifTypes, isNotEmpty,
+ ifOp = fir::IfOp::create(builder, loc, ifTypes, isNotEmpty,
/*withElseRegion=*/true);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
mlir::Value one =
@@ -590,7 +590,7 @@ MinMaxlocAsElementalConverter<T>::genReductionInitValues(
mlir::Value minMaxFirst =
hlfir::loadElementAt(loc, builder, hlfir::Entity{getSource()}, indices);
results.push_back(minMaxFirst);
- builder.create<fir::ResultOp>(loc, results);
+ fir::ResultOp::create(builder, loc, results);
// In the 'else' block use default init values.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
@@ -607,7 +607,7 @@ MinMaxlocAsElementalConverter<T>::genReductionInitValues(
result.push_back(minMaxInit);
if (ifOp) {
- builder.create<fir::ResultOp>(loc, result);
+ fir::ResultOp::create(builder, loc, result);
builder.setInsertionPointAfter(ifOp);
result = ifOp.getResults();
} else if (useIsFirst()) {
@@ -635,7 +635,7 @@ MinMaxlocAsElementalConverter<T>::reduceOneElement(
// If isFirst is true, then do the reduction update regardless
// of the FP comparison.
cmp =
- builder.create<mlir::arith::OrIOp>(loc, cmp, getIsFirst(currentValue));
+ mlir::arith::OrIOp::create(builder, loc, cmp, getIsFirst(currentValue));
}
llvm::SmallVector<mlir::Value> newIndices;
@@ -654,11 +654,11 @@ MinMaxlocAsElementalConverter<T>::reduceOneElement(
mlir::Value newCoor = builder.createConvert(
loc, currentCoor.getType(), oneBasedIndices[coorIdx + dim - 1]);
mlir::Value update =
- builder.create<mlir::arith::SelectOp>(loc, cmp, newCoor, currentCoor);
+ mlir::arith::SelectOp::create(builder, loc, cmp, newCoor, currentCoor);
newIndices.push_back(update);
}
- mlir::Value newMinMax = builder.create<mlir::arith::SelectOp>(
+ mlir::Value newMinMax = mlir::arith::SelectOp::create(builder,
loc, cmp, elementValue, getCurrentMinMax(currentValue));
newIndices.push_back(newMinMax);
@@ -711,9 +711,9 @@ hlfir::Entity MinMaxlocAsElementalConverter<T>::genFinalResult(
mlir::Value idx = builder.createIntegerConstant(loc, indexType, i + 1);
mlir::Value resultElement =
hlfir::getElementAt(loc, builder, hlfir::Entity{tempArray}, {idx});
- builder.create<hlfir::AssignOp>(loc, coor, resultElement);
+ hlfir::AssignOp::create(builder, loc, coor, resultElement);
}
- mlir::Value tempExpr = builder.create<hlfir::AsExprOp>(
+ mlir::Value tempExpr = hlfir::AsExprOp::create(builder,
loc, tempArray, builder.createBool(loc, false));
return hlfir::Entity{tempExpr};
}
@@ -792,9 +792,9 @@ class MinMaxvalAsElementalConverter
mlir::Value cmp =
genMinMaxComparison<isMax>(loc, builder, elementValue, currentMinMax);
if (useIsFirst())
- cmp = builder.create<mlir::arith::OrIOp>(loc, cmp,
+ cmp = mlir::arith::OrIOp::create(builder, loc, cmp,
getIsFirst(currentValue));
- mlir::Value newMinMax = builder.create<mlir::arith::SelectOp>(
+ mlir::Value newMinMax = mlir::arith::SelectOp::create(builder,
loc, cmp, elementValue, currentMinMax);
result.push_back(newMinMax);
if (useIsFirst())
@@ -868,12 +868,12 @@ MinMaxvalAsElementalConverter<T>::genReductionInitValues(
this->getSourceRank(), oneBasedIndices);
ifOp =
- builder.create<fir::IfOp>(loc, this->getResultElementType(), isNotEmpty,
+ fir::IfOp::create(builder, loc, this->getResultElementType(), isNotEmpty,
/*withElseRegion=*/true);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
mlir::Value minMaxFirst = hlfir::loadElementAt(
loc, builder, hlfir::Entity{this->getSource()}, indices);
- builder.create<fir::ResultOp>(loc, minMaxFirst);
+ fir::ResultOp::create(builder, loc, minMaxFirst);
// In the 'else' block use default init values.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
@@ -884,7 +884,7 @@ MinMaxvalAsElementalConverter<T>::genReductionInitValues(
result.push_back(init);
if (ifOp) {
- builder.create<fir::ResultOp>(loc, result);
+ fir::ResultOp::create(builder, loc, result);
builder.setInsertionPointAfter(ifOp);
result = ifOp.getResults();
} else if (useIsFirst()) {
@@ -992,9 +992,9 @@ class AllAnyAsElementalConverter
mlir::Value mask =
builder.createConvert(loc, builder.getI1Type(), elementValue);
if constexpr (isAll)
- return {builder.create<mlir::arith::AndIOp>(loc, mask, currentValue[0])};
+ return {mlir::arith::AndIOp::create(builder, loc, mask, currentValue[0])};
else
- return {builder.create<mlir::arith::OrIOp>(loc, mask, currentValue[0])};
+ return {mlir::arith::OrIOp::create(builder, loc, mask, currentValue[0])};
}
virtual hlfir::Entity genFinalResult(
@@ -1034,8 +1034,8 @@ class CountAsElementalConverter
mlir::Value one =
builder.createIntegerConstant(loc, getResultElementType(), 1);
mlir::Value add1 =
- builder.create<mlir::arith::AddIOp>(loc, currentValue[0], one);
- return {builder.create<mlir::arith::SelectOp>(loc, cond, add1,
+ mlir::arith::AddIOp::create(builder, loc, currentValue[0], one);
+ return {mlir::arith::SelectOp::create(builder, loc, cond, add1,
currentValue[0])};
}
};
@@ -1068,7 +1068,7 @@ mlir::LogicalResult ReductionAsElementalConverter::convert() {
// MASK represented by a box might be dynamically optional,
// so we have to check for its presence before accessing it.
isPresentPred =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), mask);
+ fir::IsPresentOp::create(builder, loc, builder.getI1Type(), mask);
}
if (hlfir::Entity{mask}.isScalar())
@@ -1120,19 +1120,19 @@ mlir::LogicalResult ReductionAsElementalConverter::convert() {
maskValue = genMaskValue(mask, isPresentPred, indices);
}
mlir::Value isUnmasked =
- builder.create<fir::ConvertOp>(loc, builder.getI1Type(), maskValue);
- ifOp = builder.create<fir::IfOp>(loc, reductionTypes, isUnmasked,
+ fir::ConvertOp::create(builder, loc, builder.getI1Type(), maskValue);
+ ifOp = fir::IfOp::create(builder, loc, reductionTypes, isUnmasked,
/*withElseRegion=*/true);
// In the 'else' block return the current reduction value.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
- builder.create<fir::ResultOp>(loc, reductionValues);
+ fir::ResultOp::create(builder, loc, reductionValues);
// In the 'then' block do the actual addition.
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
}
reductionValues = reduceOneElement(reductionValues, array, indices);
if (ifOp) {
- builder.create<fir::ResultOp>(loc, reductionValues);
+ fir::ResultOp::create(builder, loc, reductionValues);
builder.setInsertionPointAfter(ifOp);
reductionValues = ifOp.getResults();
}
@@ -1177,7 +1177,7 @@ ReductionAsElementalConverter::genResultShapeForPartialReduction(
mlir::Value dimExtent = inExtents[dimVal - 1];
inExtents.erase(inExtents.begin() + dimVal - 1);
- return {builder.create<fir::ShapeOp>(loc, inExtents), dimExtent};
+ return {fir::ShapeOp::create(builder, loc, inExtents), dimExtent};
}
mlir::Value SumAsElementalConverter::genScalarAdd(mlir::Value value1,
@@ -1185,11 +1185,11 @@ mlir::Value SumAsElementalConverter::genScalarAdd(mlir::Value value1,
mlir::Type ty = value1.getType();
assert(ty == value2.getType() && "reduction values' types do not match");
if (mlir::isa<mlir::FloatType>(ty))
- return builder.create<mlir::arith::AddFOp>(loc, value1, value2);
+ return mlir::arith::AddFOp::create(builder, loc, value1, value2);
else if (mlir::isa<mlir::ComplexType>(ty))
- return builder.create<fir::AddcOp>(loc, value1, value2);
+ return fir::AddcOp::create(builder, loc, value1, value2);
else if (mlir::isa<mlir::IntegerType>(ty))
- return builder.create<mlir::arith::AddIOp>(loc, value1, value2);
+ return mlir::arith::AddIOp::create(builder, loc, value1, value2);
llvm_unreachable("unsupported SUM reduction type");
}
@@ -1201,14 +1201,14 @@ mlir::Value ReductionAsElementalConverter::genMaskValue(
mlir::Type maskType =
hlfir::getFortranElementType(fir::unwrapPassByRefType(mask.getType()));
if (isPresentPred) {
- ifOp = builder.create<fir::IfOp>(loc, maskType, isPresentPred,
+ ifOp = fir::IfOp::create(builder, loc, maskType, isPresentPred,
/*withElseRegion=*/true);
// Use 'true', if the mask is not present.
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
mlir::Value trueValue = builder.createBool(loc, true);
trueValue = builder.createConvert(loc, maskType, trueValue);
- builder.create<fir::ResultOp>(loc, trueValue);
+ fir::ResultOp::create(builder, loc, trueValue);
// Load the mask value, if the mask is present.
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
@@ -1219,7 +1219,7 @@ mlir::Value ReductionAsElementalConverter::genMaskValue(
if (mlir::isa<fir::BaseBoxType>(mask.getType())) {
// MASK may be a boxed scalar.
mlir::Value addr = hlfir::genVariableRawAddress(loc, builder, maskVar);
- mask = builder.create<fir::LoadOp>(loc, hlfir::Entity{addr});
+ mask = fir::LoadOp::create(builder, loc, hlfir::Entity{addr});
} else {
mask = hlfir::loadTrivialScalar(loc, builder, maskVar);
}
@@ -1233,7 +1233,7 @@ mlir::Value ReductionAsElementalConverter::genMaskValue(
if (!isPresentPred)
return mask;
- builder.create<fir::ResultOp>(loc, mask);
+ fir::ResultOp::create(builder, loc, mask);
return ifOp.getResult(0);
}
@@ -1335,9 +1335,9 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
// which extent value we use.
mlir::Value zero = builder.createIntegerConstant(loc, calcType, 0);
mlir::Value one = builder.createIntegerConstant(loc, calcType, 1);
- mlir::Value isZero = builder.create<mlir::arith::CmpIOp>(
+ mlir::Value isZero = mlir::arith::CmpIOp::create(builder,
loc, mlir::arith::CmpIPredicate::eq, extent, zero);
- extent = builder.create<mlir::arith::SelectOp>(loc, isZero, one, extent);
+ extent = mlir::arith::SelectOp::create(builder, loc, isZero, one, extent);
shiftVal = fir::IntrinsicLibrary{builder, loc}.genModulo(
calcType, {shiftVal, extent});
return builder.createConvert(loc, calcType, shiftVal);
@@ -1408,17 +1408,17 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
// Such index computation allows for further loop vectorization
// in LLVM.
mlir::Value wrapBound =
- builder.create<mlir::arith::SubIOp>(loc, shiftDimExtent, shiftVal);
+ mlir::arith::SubIOp::create(builder, loc, shiftDimExtent, shiftVal);
mlir::Value adjustedShiftVal =
- builder.create<mlir::arith::SubIOp>(loc, shiftVal, shiftDimExtent);
+ mlir::arith::SubIOp::create(builder, loc, shiftVal, shiftDimExtent);
mlir::Value index =
builder.createConvert(loc, calcType, inputIndices[dimVal - 1]);
- mlir::Value wrapCheck = builder.create<mlir::arith::CmpIOp>(
+ mlir::Value wrapCheck = mlir::arith::CmpIOp::create(builder,
loc, mlir::arith::CmpIPredicate::sle, index, wrapBound);
- mlir::Value actualShift = builder.create<mlir::arith::SelectOp>(
+ mlir::Value actualShift = mlir::arith::SelectOp::create(builder,
loc, wrapCheck, shiftVal, adjustedShiftVal);
mlir::Value newIndex =
- builder.create<mlir::arith::AddIOp>(loc, index, actualShift);
+ mlir::arith::AddIOp::create(builder, loc, index, actualShift);
newIndex = builder.createConvert(loc, builder.getIndexType(), newIndex);
indices[dimVal - 1] = newIndex;
hlfir::Entity element = hlfir::getElementAt(loc, builder, array, indices);
@@ -1485,7 +1485,7 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
}
hlfir::EvaluateInMemoryOp evalOp =
- builder.create<hlfir::EvaluateInMemoryOp>(
+ hlfir::EvaluateInMemoryOp::create(builder,
loc, mlir::cast<hlfir::ExprType>(cshift.getType()), arrayShape);
builder.setInsertionPointToStart(&evalOp.getBody().front());
@@ -1550,13 +1550,13 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
srcIndices[dimVal - 1] = srcIndex;
hlfir::Entity srcElementValue =
hlfir::loadElementAt(loc, builder, srcArray, srcIndices);
- mlir::Value dstIndex = builder.create<mlir::arith::AddIOp>(
+ mlir::Value dstIndex = mlir::arith::AddIOp::create(builder,
loc, srcIndex,
- builder.create<mlir::arith::SubIOp>(loc, shiftDimExtent, shiftVal));
+ mlir::arith::SubIOp::create(builder, loc, shiftDimExtent, shiftVal));
dstIndices[dimVal - 1] = dstIndex;
hlfir::Entity dstElement = hlfir::getElementAt(
loc, builder, hlfir::Entity{resultArray}, dstIndices);
- builder.create<hlfir::AssignOp>(loc, srcElementValue, dstElement);
+ hlfir::AssignOp::create(builder, loc, srcElementValue, dstElement);
return {};
};
@@ -1576,20 +1576,20 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
assert(index.size() == 1 && "expected single loop");
mlir::Value dstIndex = builder.createConvert(loc, calcType, index[0]);
mlir::Value srcIndex =
- builder.create<mlir::arith::AddIOp>(loc, dstIndex, shiftVal);
+ mlir::arith::AddIOp::create(builder, loc, dstIndex, shiftVal);
srcIndices[dimVal - 1] = srcIndex;
hlfir::Entity srcElementValue =
hlfir::loadElementAt(loc, builder, srcArray, srcIndices);
dstIndices[dimVal - 1] = dstIndex;
hlfir::Entity dstElement = hlfir::getElementAt(
loc, builder, hlfir::Entity{resultArray}, dstIndices);
- builder.create<hlfir::AssignOp>(loc, srcElementValue, dstElement);
+ hlfir::AssignOp::create(builder, loc, srcElementValue, dstElement);
return {};
};
// Generate the second loop.
mlir::Value bound =
- builder.create<mlir::arith::SubIOp>(loc, shiftDimExtent, shiftVal);
+ mlir::arith::SubIOp::create(builder, loc, shiftDimExtent, shiftVal);
hlfir::genLoopNestWithReductions(loc, builder, {bound},
/*reductionInits=*/{}, genAssign2,
/*isUnordered=*/true);
@@ -1625,10 +1625,10 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
if (dimVal == 1 && mlir::isa<fir::BaseBoxType>(array.getType())) {
mlir::Type indexType = builder.getIndexType();
elemSize =
- builder.create<fir::BoxEleSizeOp>(loc, indexType, array.getBase());
+ fir::BoxEleSizeOp::create(builder, loc, indexType, array.getBase());
mlir::Value dimIdx =
builder.createIntegerConstant(loc, indexType, dimVal - 1);
- auto boxDim = builder.create<fir::BoxDimsOp>(
+ auto boxDim = fir::BoxDimsOp::create(builder,
loc, indexType, indexType, indexType, array.getBase(), dimIdx);
stride = boxDim.getByteStride();
}
@@ -1639,7 +1639,7 @@ class CShiftConversion : public mlir::OpRewritePattern<hlfir::CShiftOp> {
return {};
}
- mlir::Value isContiguous = builder.create<mlir::arith::CmpIOp>(
+ mlir::Value isContiguous = mlir::arith::CmpIOp::create(builder,
loc, mlir::arith::CmpIPredicate::eq, elemSize, stride);
builder.genIfOp(loc, {}, isContiguous, /*withElseRegion=*/true)
.genThen([&]() {
@@ -1711,7 +1711,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
// from Fortran runtime. The implementation needs to operate
// with the result array as an in-memory object.
hlfir::EvaluateInMemoryOp evalOp =
- builder.create<hlfir::EvaluateInMemoryOp>(
+ hlfir::EvaluateInMemoryOp::create(builder,
loc, mlir::cast<hlfir::ExprType>(matmul.getType()), resultShape);
builder.setInsertionPointToStart(&evalOp.getBody().front());
@@ -1813,7 +1813,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
llvm::SmallVector<mlir::Value> innerProductExtent =
fir::factory::deduceOptimalExtents({innerProduct1Extent},
{innerProduct2Extent});
- return {builder.create<fir::ShapeOp>(loc, newExtents),
+ return {fir::ShapeOp::create(builder, loc, newExtents),
innerProductExtent[0]};
}
@@ -1853,7 +1853,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
-> llvm::SmallVector<mlir::Value, 0> {
hlfir::Entity resultElement =
hlfir::getElementAt(loc, builder, result, oneBasedIndices);
- builder.create<hlfir::AssignOp>(loc, initValue, resultElement);
+ hlfir::AssignOp::create(builder, loc, initValue, resultElement);
return {};
};
@@ -1887,7 +1887,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
mlir::Value productValue =
ProductFactory{loc, builder}.genAccumulateProduct(
resultElementValue, lhsElementValue, rhsElementValue);
- builder.create<hlfir::AssignOp>(loc, productValue, resultElement);
+ hlfir::AssignOp::create(builder, loc, productValue, resultElement);
return {};
};
@@ -1924,7 +1924,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
mlir::Value productValue =
ProductFactory{loc, builder}.genAccumulateProduct(
resultElementValue, lhsElementValue, rhsElementValue);
- builder.create<hlfir::AssignOp>(loc, productValue, resultElement);
+ hlfir::AssignOp::create(builder, loc, productValue, resultElement);
return {};
};
hlfir::genLoopNestWithReductions(
@@ -1956,7 +1956,7 @@ class MatmulConversion : public mlir::OpRewritePattern<Op> {
mlir::Value productValue =
ProductFactory{loc, builder}.genAccumulateProduct(
resultElementValue, lhsElementValue, rhsElementValue);
- builder.create<hlfir::AssignOp>(loc, productValue, resultElement);
+ hlfir::AssignOp::create(builder, loc, productValue, resultElement);
return {};
};
hlfir::genLoopNestWithReductions(
@@ -2172,7 +2172,7 @@ class ReshapeAsElementalConversion
resultExtents.push_back(hlfir::loadElementAt(
loc, builder, shape,
builder.createIntegerConstant(loc, indexType, idx + 1)));
- auto resultShape = builder.create<fir::ShapeOp>(loc, resultExtents);
+ auto resultShape = fir::ShapeOp::create(builder, loc, resultExtents);
auto genKernel = [&](mlir::Location loc, fir::FirOpBuilder &builder,
mlir::ValueRange inputIndices) -> hlfir::Entity {
@@ -2181,9 +2181,9 @@ class ReshapeAsElementalConversion
fir::IfOp ifOp;
if (pad) {
// PAD is present. Check if this element comes from the PAD array.
- mlir::Value isInsideArray = builder.create<mlir::arith::CmpIOp>(
+ mlir::Value isInsideArray = mlir::arith::CmpIOp::create(builder,
loc, mlir::arith::CmpIPredicate::ult, linearIndex, arraySize);
- ifOp = builder.create<fir::IfOp>(loc, elementType, isInsideArray,
+ ifOp = fir::IfOp::create(builder, loc, elementType, isInsideArray,
/*withElseRegion=*/true);
// In the 'else' block, return an element from the PAD.
@@ -2196,13 +2196,13 @@ class ReshapeAsElementalConversion
// Subtract the ARRAY size from the zero-based linear index
// to get the zero-based linear index into PAD.
mlir::Value padLinearIndex =
- builder.create<mlir::arith::SubIOp>(loc, linearIndex, arraySize);
+ mlir::arith::SubIOp::create(builder, loc, linearIndex, arraySize);
llvm::SmallVector<mlir::Value, Fortran::common::maxRank> padIndices =
delinearizeIndex(loc, builder, padExtents, padLinearIndex,
/*wrapAround=*/true);
mlir::Value padElement =
hlfir::loadElementAt(loc, builder, hlfir::Entity{pad}, padIndices);
- builder.create<fir::ResultOp>(loc, padElement);
+ fir::ResultOp::create(builder, loc, padElement);
// In the 'then' block, return an element from the ARRAY.
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
@@ -2215,7 +2215,7 @@ class ReshapeAsElementalConversion
hlfir::loadElementAt(loc, builder, array, arrayIndices);
if (ifOp) {
- builder.create<fir::ResultOp>(loc, arrayElement);
+ fir::ResultOp::create(builder, loc, arrayElement);
builder.setInsertionPointAfter(ifOp);
arrayElement = ifOp.getResult(0);
}
@@ -2252,11 +2252,11 @@ class ReshapeAsElementalConversion
mlir::Value linearIndex = zero;
std::size_t idx = 0;
for (auto index : llvm::reverse(indices)) {
- mlir::Value tmp = builder.create<mlir::arith::SubIOp>(
+ mlir::Value tmp = mlir::arith::SubIOp::create(builder,
loc, builder.createConvert(loc, indexType, index), one);
- tmp = builder.create<mlir::arith::AddIOp>(loc, linearIndex, tmp);
+ tmp = mlir::arith::AddIOp::create(builder, loc, linearIndex, tmp);
if (idx + 1 < rank)
- tmp = builder.create<mlir::arith::MulIOp>(
+ tmp = mlir::arith::MulIOp::create(builder,
loc, tmp,
builder.createConvert(loc, indexType, extents[rank - idx - 2]));
@@ -2297,12 +2297,12 @@ class ReshapeAsElementalConversion
mlir::Value currentIndex = linearIndex;
if (dim != extents.size() - 1 || wrapAround)
currentIndex =
- builder.create<mlir::arith::RemUIOp>(loc, linearIndex, extent);
+ mlir::arith::RemUIOp::create(builder, loc, linearIndex, extent);
// The result of the last division is unused, so it will be DCEd.
linearIndex =
- builder.create<mlir::arith::DivUIOp>(loc, linearIndex, extent);
+ mlir::arith::DivUIOp::create(builder, loc, linearIndex, extent);
indices.push_back(
- builder.create<mlir::arith::AddIOp>(loc, currentIndex, one));
+ mlir::arith::AddIOp::create(builder, loc, currentIndex, one));
}
return indices;
}
@@ -2314,7 +2314,7 @@ class ReshapeAsElementalConversion
mlir::Type indexType = builder.getIndexType();
mlir::Value size = builder.createIntegerConstant(loc, indexType, 1);
for (auto extent : extents)
- size = builder.create<mlir::arith::MulIOp>(
+ size = mlir::arith::MulIOp::create(builder,
loc, size, builder.createConvert(loc, indexType, extent));
return size;
}
diff --git a/flang/lib/Optimizer/OpenACC/Support/FIROpenACCTypeInterfaces.cpp b/flang/lib/Optimizer/OpenACC/Support/FIROpenACCTypeInterfaces.cpp
index 8b40c643405a9..6f3ddb4be3113 100644
--- a/flang/lib/Optimizer/OpenACC/Support/FIROpenACCTypeInterfaces.cpp
+++ b/flang/lib/Optimizer/OpenACC/Support/FIROpenACCTypeInterfaces.cpp
@@ -244,14 +244,14 @@ generateSeqTyAccBounds(fir::SequenceType seqType, mlir::Value var,
mlir::Value cummulativeExtent = one;
for (auto extent : shapeOp.getExtents()) {
mlir::Value upperbound =
- builder.create<mlir::arith::SubIOp>(loc, extent, one);
+ mlir::arith::SubIOp::create(builder, loc, extent, one);
mlir::Value stride = one;
if (strideIncludeLowerExtent) {
stride = cummulativeExtent;
- cummulativeExtent = builder.create<mlir::arith::MulIOp>(
+ cummulativeExtent = mlir::arith::MulIOp::create(builder,
loc, cummulativeExtent, extent);
}
- auto accBound = builder.create<mlir::acc::DataBoundsOp>(
+ auto accBound = mlir::acc::DataBoundsOp::create(builder,
loc, mlir::acc::DataBoundsType::get(builder.getContext()),
/*lowerbound=*/zero, /*upperbound=*/upperbound,
/*extent=*/extent, /*stride=*/stride, /*strideInBytes=*/false,
@@ -269,16 +269,16 @@ generateSeqTyAccBounds(fir::SequenceType seqType, mlir::Value var,
} else {
mlir::Value extent = val;
mlir::Value upperbound =
- builder.create<mlir::arith::SubIOp>(loc, extent, one);
- upperbound = builder.create<mlir::arith::AddIOp>(loc, lowerbound,
+ mlir::arith::SubIOp::create(builder, loc, extent, one);
+ upperbound = mlir::arith::AddIOp::create(builder, loc, lowerbound,
upperbound);
mlir::Value stride = one;
if (strideIncludeLowerExtent) {
stride = cummulativeExtent;
- cummulativeExtent = builder.create<mlir::arith::MulIOp>(
+ cummulativeExtent = mlir::arith::MulIOp::create(builder,
loc, cummulativeExtent, extent);
}
- auto accBound = builder.create<mlir::acc::DataBoundsOp>(
+ auto accBound = mlir::acc::DataBoundsOp::create(builder,
loc, mlir::acc::DataBoundsType::get(builder.getContext()),
/*lowerbound=*/zero, /*upperbound=*/upperbound,
/*extent=*/extent, /*stride=*/stride, /*strideInBytes=*/false,
@@ -531,9 +531,9 @@ static fir::ShapeOp genShapeOp(mlir::OpBuilder &builder,
llvm::SmallVector<mlir::Value> extents;
mlir::Type idxTy = builder.getIndexType();
for (auto extent : seqTy.getShape())
- extents.push_back(builder.create<mlir::arith::ConstantOp>(
+ extents.push_back(mlir::arith::ConstantOp::create(builder,
loc, idxTy, builder.getIntegerAttr(idxTy, extent)));
- return builder.create<fir::ShapeOp>(loc, extents);
+ return fir::ShapeOp::create(builder, loc, extents);
}
template <typename Ty>
@@ -549,8 +549,8 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
fir::FirOpBuilder firBuilder(builder, mod);
auto getDeclareOpForType = [&](mlir::Type ty) -> hlfir::DeclareOp {
- auto alloca = firBuilder.create<fir::AllocaOp>(loc, ty);
- return firBuilder.create<hlfir::DeclareOp>(
+ auto alloca = fir::AllocaOp::create(firBuilder, loc, ty);
+ return hlfir::DeclareOp::create(firBuilder,
loc, alloca, varName, /*shape=*/nullptr, llvm::ArrayRef<mlir::Value>{},
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
};
@@ -559,7 +559,7 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
auto declareOp = getDeclareOpForType(unwrappedTy);
if (initVal) {
auto convert = firBuilder.createConvert(loc, unwrappedTy, initVal);
- firBuilder.create<fir::StoreOp>(loc, convert, declareOp.getBase());
+ fir::StoreOp::create(firBuilder, loc, convert, declareOp.getBase());
}
retVal = declareOp.getBase();
} else if (auto seqTy =
@@ -567,13 +567,13 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
if (fir::isa_trivial(seqTy.getEleTy())) {
mlir::Value shape;
if (seqTy.hasDynamicExtents()) {
- shape = firBuilder.create<fir::ShapeOp>(loc, llvm::to_vector(extents));
+ shape = fir::ShapeOp::create(firBuilder, loc, llvm::to_vector(extents));
} else {
shape = genShapeOp(firBuilder, seqTy, loc);
}
- auto alloca = firBuilder.create<fir::AllocaOp>(
+ auto alloca = fir::AllocaOp::create(firBuilder,
loc, seqTy, /*typeparams=*/mlir::ValueRange{}, extents);
- auto declareOp = firBuilder.create<hlfir::DeclareOp>(
+ auto declareOp = hlfir::DeclareOp::create(firBuilder,
loc, alloca, varName, shape, llvm::ArrayRef<mlir::Value>{},
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
@@ -584,21 +584,21 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
llvm::SmallVector<mlir::Value> ivs;
if (seqTy.hasDynamicExtents()) {
- firBuilder.create<hlfir::AssignOp>(loc, initVal, declareOp.getBase());
+ hlfir::AssignOp::create(firBuilder, loc, initVal, declareOp.getBase());
} else {
for (auto ext : seqTy.getShape()) {
auto lb = firBuilder.createIntegerConstant(loc, idxTy, 0);
auto ub = firBuilder.createIntegerConstant(loc, idxTy, ext - 1);
auto step = firBuilder.createIntegerConstant(loc, idxTy, 1);
- auto loop = firBuilder.create<fir::DoLoopOp>(loc, lb, ub, step,
+ auto loop = fir::DoLoopOp::create(firBuilder, loc, lb, ub, step,
/*unordered=*/false);
firBuilder.setInsertionPointToStart(loop.getBody());
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
}
- auto coord = firBuilder.create<fir::CoordinateOp>(
+ auto coord = fir::CoordinateOp::create(firBuilder,
loc, refTy, declareOp.getBase(), ivs);
- firBuilder.create<fir::StoreOp>(loc, initVal, coord);
+ fir::StoreOp::create(firBuilder, loc, initVal, coord);
firBuilder.setInsertionPointAfter(loops[0]);
}
}
@@ -626,7 +626,7 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
storeDst = firBuilder.createConvert(
loc, firBuilder.getRefType(temp.getType()), retVal);
}
- builder.create<fir::StoreOp>(loc, temp, storeDst);
+ fir::StoreOp::create(builder, loc, temp, storeDst);
} else {
retVal = temp;
}
@@ -634,7 +634,7 @@ mlir::Value OpenACCMappableModel<Ty>::generatePrivateInit(
TODO(loc, "Unsupported boxed type for OpenACC private-like recipe");
}
if (initVal) {
- builder.create<hlfir::AssignOp>(loc, initVal, retVal);
+ hlfir::AssignOp::create(builder, loc, initVal, retVal);
}
}
return retVal;
diff --git a/flang/lib/Optimizer/OpenMP/DoConcurrentConversion.cpp b/flang/lib/Optimizer/OpenMP/DoConcurrentConversion.cpp
index 31076f6eb328f..6d3a32f9d37e0 100644
--- a/flang/lib/Optimizer/OpenMP/DoConcurrentConversion.cpp
+++ b/flang/lib/Optimizer/OpenMP/DoConcurrentConversion.cpp
@@ -246,9 +246,9 @@ class DoConcurrentConversion
genParallelOp(mlir::Location loc, mlir::ConversionPatternRewriter &rewriter,
looputils::InductionVariableInfos &ivInfos,
mlir::IRMapping &mapper) const {
- auto parallelOp = rewriter.create<mlir::omp::ParallelOp>(loc);
+ auto parallelOp = mlir::omp::ParallelOp::create(rewriter, loc);
rewriter.createBlock(¶llelOp.getRegion());
- rewriter.setInsertionPoint(rewriter.create<mlir::omp::TerminatorOp>(loc));
+ rewriter.setInsertionPoint(mlir::omp::TerminatorOp::create(rewriter, loc));
genLoopNestIndVarAllocs(rewriter, ivInfos, mapper);
return parallelOp;
@@ -319,7 +319,7 @@ class DoConcurrentConversion
auto firYield =
mlir::cast<fir::YieldOp>(ompRegion.back().getTerminator());
rewriter.setInsertionPoint(firYield);
- rewriter.create<mlir::omp::YieldOp>(firYield.getLoc(),
+ mlir::omp::YieldOp::create(rewriter, firYield.getLoc(),
firYield.getOperands());
rewriter.eraseOp(firYield);
}
@@ -342,7 +342,7 @@ class DoConcurrentConversion
mlir::OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointAfter(localizer);
- auto privatizer = rewriter.create<mlir::omp::PrivateClauseOp>(
+ auto privatizer = mlir::omp::PrivateClauseOp::create(rewriter,
localizer.getLoc(), sym.getLeafReference().str() + ".omp",
localizer.getTypeAttr().getValue(),
mlir::omp::DataSharingClauseType::Private);
@@ -369,7 +369,7 @@ class DoConcurrentConversion
mlir::OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointAfter(firReducer);
- auto ompReducer = rewriter.create<mlir::omp::DeclareReductionOp>(
+ auto ompReducer = mlir::omp::DeclareReductionOp::create(rewriter,
firReducer.getLoc(), sym.getLeafReference().str() + ".omp",
firReducer.getTypeAttr().getValue());
@@ -392,7 +392,7 @@ class DoConcurrentConversion
}
auto wsloopOp =
- rewriter.create<mlir::omp::WsloopOp>(loop.getLoc(), wsloopClauseOps);
+ mlir::omp::WsloopOp::create(rewriter, loop.getLoc(), wsloopClauseOps);
wsloopOp.setComposite(isComposite);
Fortran::common::openmp::EntryBlockArgs wsloopArgs;
@@ -402,7 +402,7 @@ class DoConcurrentConversion
wsloopOp.getRegion());
auto loopNestOp =
- rewriter.create<mlir::omp::LoopNestOp>(loop.getLoc(), clauseOps);
+ mlir::omp::LoopNestOp::create(rewriter, loop.getLoc(), clauseOps);
// Clone the loop's body inside the loop nest construct using the
// mapped values.
@@ -410,7 +410,7 @@ class DoConcurrentConversion
loopNestOp.getRegion().begin(), mapper);
rewriter.setInsertionPointToEnd(&loopNestOp.getRegion().back());
- rewriter.create<mlir::omp::YieldOp>(loop->getLoc());
+ mlir::omp::YieldOp::create(rewriter, loop->getLoc());
// `local` region arguments are transferred/cloned from the `do concurrent`
// loop to the loopnest op when the region is cloned above. Instead, these
diff --git a/flang/lib/Optimizer/OpenMP/FunctionFiltering.cpp b/flang/lib/Optimizer/OpenMP/FunctionFiltering.cpp
index 9554808824ac3..ae5c0ecc5b7f6 100644
--- a/flang/lib/Optimizer/OpenMP/FunctionFiltering.cpp
+++ b/flang/lib/Optimizer/OpenMP/FunctionFiltering.cpp
@@ -83,7 +83,7 @@ class FunctionFilteringPass
for (Value res : callOp->getResults()) {
opBuilder.setInsertionPoint(callOp);
undefResults.emplace_back(
- opBuilder.create<fir::UndefOp>(res.getLoc(), res.getType()));
+ fir::UndefOp::create(opBuilder, res.getLoc(), res.getType()));
}
callOp->replaceAllUsesWith(undefResults);
}
diff --git a/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp b/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
index 3009746954984..50dc19c6659c8 100644
--- a/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
+++ b/flang/lib/Optimizer/OpenMP/GenericLoopConversion.cpp
@@ -280,7 +280,7 @@ class GenericLoopConversionPattern
args.reduction.vars = clauseOps.reductionVars;
}
- auto wrapperOp = rewriter.create<OpTy>(loopOp.getLoc(), clauseOps);
+ auto wrapperOp = OpTy::create(rewriter, loopOp.getLoc(), clauseOps);
mlir::Block *opBlock = genEntryBlock(rewriter, args, wrapperOp.getRegion());
mlir::IRMapping mapper;
@@ -307,15 +307,15 @@ class GenericLoopConversionPattern
Fortran::common::openmp::EntryBlockArgs parallelArgs;
parallelArgs.priv.vars = parallelClauseOps.privateVars;
- auto parallelOp = rewriter.create<mlir::omp::ParallelOp>(loopOp.getLoc(),
+ auto parallelOp = mlir::omp::ParallelOp::create(rewriter, loopOp.getLoc(),
parallelClauseOps);
genEntryBlock(rewriter, parallelArgs, parallelOp.getRegion());
parallelOp.setComposite(true);
rewriter.setInsertionPoint(
- rewriter.create<mlir::omp::TerminatorOp>(loopOp.getLoc()));
+ mlir::omp::TerminatorOp::create(rewriter, loopOp.getLoc()));
mlir::omp::DistributeOperands distributeClauseOps;
- auto distributeOp = rewriter.create<mlir::omp::DistributeOp>(
+ auto distributeOp = mlir::omp::DistributeOp::create(rewriter,
loopOp.getLoc(), distributeClauseOps);
distributeOp.setComposite(true);
rewriter.createBlock(&distributeOp.getRegion());
@@ -326,7 +326,7 @@ class GenericLoopConversionPattern
wsloopArgs.reduction.vars = wsloopClauseOps.reductionVars;
auto wsloopOp =
- rewriter.create<mlir::omp::WsloopOp>(loopOp.getLoc(), wsloopClauseOps);
+ mlir::omp::WsloopOp::create(rewriter, loopOp.getLoc(), wsloopClauseOps);
wsloopOp.setComposite(true);
genEntryBlock(rewriter, wsloopArgs, wsloopOp.getRegion());
diff --git a/flang/lib/Optimizer/OpenMP/LowerWorkshare.cpp b/flang/lib/Optimizer/OpenMP/LowerWorkshare.cpp
index 27a57f73d4e97..f6af684f06edb 100644
--- a/flang/lib/Optimizer/OpenMP/LowerWorkshare.cpp
+++ b/flang/lib/Optimizer/OpenMP/LowerWorkshare.cpp
@@ -160,17 +160,17 @@ static mlir::func::FuncOp createCopyFunc(mlir::Location loc, mlir::Type varType,
llvm::SmallVector<mlir::Type> argsTy = {varType, varType};
auto funcType = mlir::FunctionType::get(builder.getContext(), argsTy, {});
mlir::func::FuncOp funcOp =
- modBuilder.create<mlir::func::FuncOp>(loc, copyFuncName, funcType);
+ mlir::func::FuncOp::create(modBuilder, loc, copyFuncName, funcType);
funcOp.setVisibility(mlir::SymbolTable::Visibility::Private);
fir::factory::setInternalLinkage(funcOp);
builder.createBlock(&funcOp.getRegion(), funcOp.getRegion().end(), argsTy,
{loc, loc});
builder.setInsertionPointToStart(&funcOp.getRegion().back());
- Value loaded = builder.create<fir::LoadOp>(loc, funcOp.getArgument(1));
- builder.create<fir::StoreOp>(loc, loaded, funcOp.getArgument(0));
+ Value loaded = fir::LoadOp::create(builder, loc, funcOp.getArgument(1));
+ fir::StoreOp::create(builder, loc, loaded, funcOp.getArgument(0));
- builder.create<mlir::func::ReturnOp>(loc);
+ mlir::func::ReturnOp::create(builder, loc);
return funcOp;
}
@@ -234,9 +234,9 @@ static void parallelizeRegion(Region &sourceRegion, Region &targetRegion,
if (auto reloaded = rootMapping.lookupOrNull(v))
return nullptr;
Type ty = v.getType();
- Value alloc = allocaBuilder.create<fir::AllocaOp>(loc, ty);
- singleBuilder.create<fir::StoreOp>(loc, singleMapping.lookup(v), alloc);
- Value reloaded = parallelBuilder.create<fir::LoadOp>(loc, ty, alloc);
+ Value alloc = fir::AllocaOp::create(allocaBuilder, loc, ty);
+ fir::StoreOp::create(singleBuilder, loc, singleMapping.lookup(v), alloc);
+ Value reloaded = fir::LoadOp::create(parallelBuilder, loc, ty, alloc);
rootMapping.map(v, reloaded);
return alloc;
};
@@ -293,7 +293,7 @@ static void parallelizeRegion(Region &sourceRegion, Region &targetRegion,
allParallelized = false;
}
}
- singleBuilder.create<omp::TerminatorOp>(loc);
+ omp::TerminatorOp::create(singleBuilder, loc);
return {allParallelized, copyPrivate};
};
@@ -370,7 +370,7 @@ static void parallelizeRegion(Region &sourceRegion, Region &targetRegion,
SymbolRefAttr::get(funcOp));
}
omp::SingleOp singleOp =
- rootBuilder.create<omp::SingleOp>(loc, singleOperands);
+ omp::SingleOp::create(rootBuilder, loc, singleOperands);
singleOp.getRegion().push_back(singleBlock);
targetRegion.front().getOperations().splice(
singleOp->getIterator(), allocaBlock->getOperations());
@@ -386,7 +386,7 @@ static void parallelizeRegion(Region &sourceRegion, Region &targetRegion,
if (isLast)
wsloopOperands.nowait = rootBuilder.getUnitAttr();
auto wsloop =
- rootBuilder.create<mlir::omp::WsloopOp>(loc, wsloopOperands);
+ mlir::omp::WsloopOp::create(rootBuilder, loc, wsloopOperands);
auto clonedWslw = cast<omp::WorkshareLoopWrapperOp>(
rootBuilder.clone(*wslw, rootMapping));
wsloop.getRegion().takeBody(clonedWslw.getRegion());
@@ -465,9 +465,9 @@ LogicalResult lowerWorkshare(mlir::omp::WorkshareOp wsOp, DominanceInfo &di) {
// it because our `parallelizeRegion` function works on regions and not
// blocks.
omp::WorkshareOp newOp =
- rootBuilder.create<omp::WorkshareOp>(loc, omp::WorkshareOperands());
+ omp::WorkshareOp::create(rootBuilder, loc, omp::WorkshareOperands());
if (!wsOp.getNowait())
- rootBuilder.create<omp::BarrierOp>(loc);
+ omp::BarrierOp::create(rootBuilder, loc);
parallelizeRegion(wsOp.getRegion(), newOp.getRegion(), rootMapping, loc,
di);
@@ -505,7 +505,7 @@ LogicalResult lowerWorkshare(mlir::omp::WorkshareOp wsOp, DominanceInfo &di) {
omp::SingleOperands operands;
operands.nowait = wsOp.getNowaitAttr();
- omp::SingleOp newOp = rootBuilder.create<omp::SingleOp>(loc, operands);
+ omp::SingleOp newOp = omp::SingleOp::create(rootBuilder, loc, operands);
newOp.getRegion().getBlocks().splice(newOp.getRegion().getBlocks().begin(),
wsOp.getRegion().getBlocks());
diff --git a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
index f052cf8d22d1e..0db273ab88ed9 100644
--- a/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapInfoFinalization.cpp
@@ -158,17 +158,17 @@ class MapInfoFinalizationPass
mlir::Type allocaType = descriptor.getType();
if (fir::isBoxAddress(allocaType))
allocaType = fir::unwrapRefType(allocaType);
- auto alloca = builder.create<fir::AllocaOp>(loc, allocaType);
+ auto alloca = fir::AllocaOp::create(builder, loc, allocaType);
builder.restoreInsertionPoint(insPt);
// We should only emit a store if the passed in data is present, it is
// possible a user passes in no argument to an optional parameter, in which
// case we cannot store or we'll segfault on the emitted memcpy.
auto isPresent =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), descriptor);
+ fir::IsPresentOp::create(builder, loc, builder.getI1Type(), descriptor);
builder.genIfOp(loc, {}, isPresent, false)
.genThen([&]() {
descriptor = builder.loadIfRef(loc, descriptor);
- builder.create<fir::StoreOp>(loc, descriptor, alloca);
+ fir::StoreOp::create(builder, loc, descriptor, alloca);
})
.end();
return slot = alloca;
@@ -183,7 +183,7 @@ class MapInfoFinalizationPass
int64_t mapType,
fir::FirOpBuilder &builder) {
mlir::Location loc = descriptor.getLoc();
- mlir::Value baseAddrAddr = builder.create<fir::BoxOffsetOp>(
+ mlir::Value baseAddrAddr = fir::BoxOffsetOp::create(builder,
loc, descriptor, fir::BoxFieldAttr::base_addr);
mlir::Type underlyingVarType =
@@ -195,7 +195,7 @@ class MapInfoFinalizationPass
underlyingVarType = seqType.getEleTy();
// Member of the descriptor pointing at the allocated data
- return builder.create<mlir::omp::MapInfoOp>(
+ return mlir::omp::MapInfoOp::create(builder,
loc, baseAddrAddr.getType(), descriptor,
mlir::TypeAttr::get(underlyingVarType),
builder.getIntegerAttr(builder.getIntegerType(64, false), mapType),
@@ -293,11 +293,11 @@ class MapInfoFinalizationPass
mlir::Value boxChar = op.getVarPtr();
if (mlir::isa<fir::ReferenceType>(op.getVarPtr().getType()))
- boxChar = builder.create<fir::LoadOp>(loc, op.getVarPtr());
+ boxChar = fir::LoadOp::create(builder, loc, op.getVarPtr());
fir::BoxCharType boxCharType =
mlir::dyn_cast<fir::BoxCharType>(boxChar.getType());
- mlir::Value boxAddr = builder.create<fir::BoxOffsetOp>(
+ mlir::Value boxAddr = fir::BoxOffsetOp::create(builder,
loc, op.getVarPtr(), fir::BoxFieldAttr::base_addr);
uint64_t mapTypeToImplicit = static_cast<
@@ -310,7 +310,7 @@ class MapInfoFinalizationPass
newMembersAttr = builder.create2DI64ArrayAttr(memberIdx);
mlir::Value varPtr = op.getVarPtr();
- mlir::omp::MapInfoOp memberMapInfoOp = builder.create<mlir::omp::MapInfoOp>(
+ mlir::omp::MapInfoOp memberMapInfoOp = mlir::omp::MapInfoOp::create(builder,
op.getLoc(), varPtr.getType(), varPtr,
mlir::TypeAttr::get(boxCharType.getEleTy()),
builder.getIntegerAttr(builder.getIntegerType(64, /*isSigned=*/false),
@@ -324,7 +324,7 @@ class MapInfoFinalizationPass
/*mapperId=*/mlir::FlatSymbolRefAttr(), /*name=*/op.getNameAttr(),
builder.getBoolAttr(false));
- mlir::omp::MapInfoOp newMapInfoOp = builder.create<mlir::omp::MapInfoOp>(
+ mlir::omp::MapInfoOp newMapInfoOp = mlir::omp::MapInfoOp::create(builder,
op.getLoc(), op.getResult().getType(), varPtr,
mlir::TypeAttr::get(
llvm::cast<mlir::omp::PointerLikeType>(varPtr.getType())
@@ -426,7 +426,7 @@ class MapInfoFinalizationPass
}
mlir::omp::MapInfoOp newDescParentMapOp =
- builder.create<mlir::omp::MapInfoOp>(
+ mlir::omp::MapInfoOp::create(builder,
op->getLoc(), op.getResult().getType(), descriptor,
mlir::TypeAttr::get(fir::unwrapRefType(descriptor.getType())),
builder.getIntegerAttr(builder.getIntegerType(64, false),
@@ -739,7 +739,7 @@ class MapInfoFinalizationPass
builder.setInsertionPoint(op);
fir::IntOrValue idxConst =
mlir::IntegerAttr::get(builder.getI32Type(), fieldIdx);
- auto fieldCoord = builder.create<fir::CoordinateOp>(
+ auto fieldCoord = fir::CoordinateOp::create(builder,
op.getLoc(), builder.getRefType(memTy), op.getVarPtr(),
llvm::SmallVector<fir::IntOrValue, 1>{idxConst});
fir::factory::AddrAndBoundsInfo info =
@@ -755,7 +755,7 @@ class MapInfoFinalizationPass
/*dataExvIsAssumedSize=*/false, op.getLoc());
mlir::omp::MapInfoOp fieldMapOp =
- builder.create<mlir::omp::MapInfoOp>(
+ mlir::omp::MapInfoOp::create(builder,
op.getLoc(), fieldCoord.getResult().getType(),
fieldCoord.getResult(),
mlir::TypeAttr::get(
diff --git a/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp b/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
index 19566af11db04..e007a80512513 100644
--- a/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
+++ b/flang/lib/Optimizer/OpenMP/MapsForPrivatizedSymbols.cpp
@@ -80,9 +80,9 @@ class MapsForPrivatizedSymbolsPass
mlir::Block *allocaBlock = builder.getAllocaBlock();
assert(allocaBlock && "No allocablock found for a funcOp");
builder.setInsertionPointToStart(allocaBlock);
- auto alloca = builder.create<fir::AllocaOp>(loc, varPtr.getType());
+ auto alloca = fir::AllocaOp::create(builder, loc, varPtr.getType());
builder.restoreInsertionPoint(savedInsPoint);
- builder.create<fir::StoreOp>(loc, varPtr, alloca);
+ fir::StoreOp::create(builder, loc, varPtr, alloca);
varPtr = alloca;
}
assert(mlir::isa<omp::PointerLikeType>(varPtr.getType()) &&
@@ -94,7 +94,7 @@ class MapsForPrivatizedSymbolsPass
if (needsBoundsOps(varPtr))
genBoundsOps(builder, varPtr, boundsOps);
- return builder.create<omp::MapInfoOp>(
+ return omp::MapInfoOp::create(builder,
loc, varPtr.getType(), varPtr,
TypeAttr::get(llvm::cast<omp::PointerLikeType>(varPtr.getType())
.getElementType()),
More information about the flang-commits
mailing list