[flang-commits] [flang] [flang][NFC] Move the rest of ops creation to new APIs (PR #152079)
Valentin Clement バレンタイン クレメン via flang-commits
flang-commits at lists.llvm.org
Mon Aug 4 22:20:28 PDT 2025
https://github.com/clementval created https://github.com/llvm/llvm-project/pull/152079
See https://github.com/llvm/llvm-project/pull/147168
This should be the last patch to move all the rest of ops creation to the new APIs in flang.
>From 9d8dbfea49e8b585d6c27e941ec0cfffb30782ec Mon Sep 17 00:00:00 2001
From: Valentin Clement <clementval at gmail.com>
Date: Mon, 4 Aug 2025 22:18:17 -0700
Subject: [PATCH] [flang][NFC] Move the rest of ops creation to new APIs
---
.../flang/Optimizer/Builder/FIRBuilder.h | 11 ++-
.../include/flang/Optimizer/Builder/Factory.h | 42 ++++----
.../Dialect/CanonicalizationPatterns.td | 4 +-
flang/lib/Lower/Bridge.cpp | 97 ++++++++++---------
flang/lib/Lower/OpenMP/OpenMP.cpp | 79 +++++++--------
flang/lib/Optimizer/Builder/FIRBuilder.cpp | 28 +++---
flang/lib/Optimizer/Builder/IntrinsicCall.cpp | 18 ++--
flang/lib/Optimizer/CodeGen/CodeGen.cpp | 14 +--
flang/lib/Optimizer/CodeGen/TargetRewrite.cpp | 19 ++--
.../Optimizer/Builder/HLFIRToolsTest.cpp | 4 +-
.../Optimizer/FortranVariableTest.cpp | 10 +-
11 files changed, 167 insertions(+), 159 deletions(-)
diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
index 8b4c2f73a84e8..d8b6a9f87ab19 100644
--- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -549,8 +549,9 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
}
mlir::Value genNot(mlir::Location loc, mlir::Value boolean) {
- return create<mlir::arith::CmpIOp>(loc, mlir::arith::CmpIPredicate::eq,
- boolean, createBool(loc, false));
+ return mlir::arith::CmpIOp::create(*this, loc,
+ mlir::arith::CmpIPredicate::eq, boolean,
+ createBool(loc, false));
}
/// Generate code testing \p addr is not a null address.
@@ -641,7 +642,7 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
mlir::Value createUnsigned(mlir::Location loc, mlir::Type resultType,
mlir::Value left, mlir::Value right) {
if (!resultType.isIntOrFloat())
- return create<OpTy>(loc, resultType, left, right);
+ return OpTy::create(*this, loc, resultType, left, right);
mlir::Type signlessType = mlir::IntegerType::get(
getContext(), resultType.getIntOrFloatBitWidth(),
mlir::IntegerType::SignednessSemantics::Signless);
@@ -654,7 +655,7 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
right = createConvert(loc, signlessType, right);
opResType = signlessType;
}
- mlir::Value result = create<OpTy>(loc, opResType, left, right);
+ mlir::Value result = OpTy::create(*this, loc, opResType, left, right);
if (resultType.isUnsignedInteger())
result = createConvert(loc, resultType, result);
return result;
@@ -666,7 +667,7 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
mlir::Value ptr1, mlir::Value ptr2) {
ptr1 = createConvert(loc, getIndexType(), ptr1);
ptr2 = createConvert(loc, getIndexType(), ptr2);
- return create<mlir::arith::CmpIOp>(loc, predicate, ptr1, ptr2);
+ return mlir::arith::CmpIOp::create(*this, loc, predicate, ptr1, ptr2);
}
private:
diff --git a/flang/include/flang/Optimizer/Builder/Factory.h b/flang/include/flang/Optimizer/Builder/Factory.h
index e67ef457c8b4c..fd9f33c340fa9 100644
--- a/flang/include/flang/Optimizer/Builder/Factory.h
+++ b/flang/include/flang/Optimizer/Builder/Factory.h
@@ -53,8 +53,8 @@ void genCharacterCopy(mlir::Value src, mlir::Value srcLen, mlir::Value dst,
fir::StoreOp::create(builder, loc, load, dst);
return;
}
- auto zero = builder.template create<mlir::arith::ConstantIndexOp>(loc, 0);
- auto one = builder.template create<mlir::arith::ConstantIndexOp>(loc, 1);
+ auto zero = mlir::arith::ConstantIndexOp::create(builder, loc, 0);
+ auto one = mlir::arith::ConstantIndexOp::create(builder, loc, 1);
auto toArrayTy = [&](fir::CharacterType ty) {
return fir::ReferenceType::get(fir::SequenceType::get(
fir::SequenceType::ShapeRef{fir::SequenceType::getUnknownExtent()},
@@ -68,8 +68,8 @@ void genCharacterCopy(mlir::Value src, mlir::Value srcLen, mlir::Value dst,
return fir::ReferenceType::get(toEleTy(ty));
};
if (!srcLen && !dstLen && srcTy.getLen() >= dstTy.getLen()) {
- auto upper = builder.template create<mlir::arith::ConstantIndexOp>(
- loc, dstTy.getLen() - 1);
+ auto upper =
+ mlir::arith::ConstantIndexOp::create(builder, loc, dstTy.getLen() - 1);
auto loop = fir::DoLoopOp::create(builder, loc, zero, upper, one);
auto insPt = builder.saveInsertionPoint();
builder.setInsertionPointToStart(loop.getBody());
@@ -92,26 +92,26 @@ void genCharacterCopy(mlir::Value src, mlir::Value srcLen, mlir::Value dst,
return;
}
auto minusOne = [&](mlir::Value v) -> mlir::Value {
- return builder.template create<mlir::arith::SubIOp>(
- loc, fir::ConvertOp::create(builder, loc, one.getType(), v), one);
+ return mlir::arith::SubIOp::create(
+ builder, loc, fir::ConvertOp::create(builder, loc, one.getType(), v),
+ one);
};
mlir::Value len = dstLen ? minusOne(dstLen)
- : builder
- .template create<mlir::arith::ConstantIndexOp>(
- loc, dstTy.getLen() - 1)
+ : mlir::arith::ConstantIndexOp::create(
+ builder, loc, dstTy.getLen() - 1)
.getResult();
auto loop = fir::DoLoopOp::create(builder, loc, zero, len, one);
auto insPt = builder.saveInsertionPoint();
builder.setInsertionPointToStart(loop.getBody());
mlir::Value slen =
- srcLen ? fir::ConvertOp::create(builder, loc, one.getType(), srcLen)
- .getResult()
- : builder
- .template create<mlir::arith::ConstantIndexOp>(
- loc, srcTy.getLen())
- .getResult();
- auto cond = builder.template create<mlir::arith::CmpIOp>(
- loc, mlir::arith::CmpIPredicate::slt, loop.getInductionVar(), slen);
+ srcLen
+ ? fir::ConvertOp::create(builder, loc, one.getType(), srcLen)
+ .getResult()
+ : mlir::arith::ConstantIndexOp::create(builder, loc, srcTy.getLen())
+ .getResult();
+ auto cond =
+ mlir::arith::CmpIOp::create(builder, loc, mlir::arith::CmpIPredicate::slt,
+ loop.getInductionVar(), slen);
auto ifOp = fir::IfOp::create(builder, loc, cond, /*withElse=*/true);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
auto csrcTy = toArrayTy(srcTy);
@@ -189,7 +189,7 @@ originateIndices(mlir::Location loc, B &builder, mlir::Type memTy,
auto ty = fir::dyn_cast_ptrOrBoxEleTy(memTy);
assert(ty && mlir::isa<fir::SequenceType>(ty));
auto seqTy = mlir::cast<fir::SequenceType>(ty);
- auto one = builder.template create<mlir::arith::ConstantIndexOp>(loc, 1);
+ auto one = mlir::arith::ConstantIndexOp::create(builder, loc, 1);
const auto dimension = seqTy.getDimension();
if (shapeVal) {
assert(dimension == mlir::cast<fir::ShapeOp>(shapeVal.getDefiningOp())
@@ -200,7 +200,7 @@ originateIndices(mlir::Location loc, B &builder, mlir::Type memTy,
if (i.index() < dimension) {
assert(fir::isa_integer(i.value().getType()));
result.push_back(
- builder.template create<mlir::arith::AddIOp>(loc, i.value(), one));
+ mlir::arith::AddIOp::create(builder, loc, i.value(), one));
} else {
result.push_back(i.value());
}
@@ -211,8 +211,8 @@ originateIndices(mlir::Location loc, B &builder, mlir::Type memTy,
unsigned origOff = 0;
for (auto i : llvm::enumerate(indices)) {
if (i.index() < dimension)
- result.push_back(builder.template create<mlir::arith::AddIOp>(
- loc, i.value(), origins[origOff++]));
+ result.push_back(mlir::arith::AddIOp::create(builder, loc, i.value(),
+ origins[origOff++]));
else
result.push_back(i.value());
}
diff --git a/flang/include/flang/Optimizer/Dialect/CanonicalizationPatterns.td b/flang/include/flang/Optimizer/Dialect/CanonicalizationPatterns.td
index 2414de496d45b..8341720d34c1e 100644
--- a/flang/include/flang/Optimizer/Dialect/CanonicalizationPatterns.td
+++ b/flang/include/flang/Optimizer/Dialect/CanonicalizationPatterns.td
@@ -105,8 +105,8 @@ def CombineConvertTruncOptPattern
(IntPred $arg, $irm), (SmallerWidthPred $arg, $irm)]>;
def createConstantOp
- : NativeCodeCall<"$_builder.create<mlir::arith::ConstantOp>"
- "($_loc, $_builder.getIndexType(), "
+ : NativeCodeCall<"mlir::arith::ConstantOp::create"
+ "($_builder, $_loc, $_builder.getIndexType(), "
"rewriter.getIndexAttr("
"mlir::dyn_cast<mlir::IntegerAttr>($1).getInt()))">;
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index 61476efbee1fc..c56de2d4d1e1f 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -1458,7 +1458,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
void genBranch(mlir::Block *targetBlock) {
assert(targetBlock && "missing unconditional target block");
- builder->create<mlir::cf::BranchOp>(toLocation(), targetBlock);
+ mlir::cf::BranchOp::create(*builder, toLocation(), targetBlock);
}
void genConditionalBranch(mlir::Value cond, mlir::Block *trueTarget,
@@ -1467,9 +1467,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
assert(falseTarget && "missing conditional branch false block");
mlir::Location loc = toLocation();
mlir::Value bcc = builder->createConvert(loc, builder->getI1Type(), cond);
- builder->create<mlir::cf::CondBranchOp>(loc, bcc, trueTarget,
- mlir::ValueRange{}, falseTarget,
- mlir::ValueRange{});
+ mlir::cf::CondBranchOp::create(*builder, loc, bcc, trueTarget,
+ mlir::ValueRange{}, falseTarget,
+ mlir::ValueRange{});
}
void genConditionalBranch(mlir::Value cond,
Fortran::lower::pft::Evaluation *trueTarget,
@@ -1637,28 +1637,28 @@ class FirConverter : public Fortran::lower::AbstractConverter {
assert((inArithmeticIfContext || !realSelector) && "invalid selector type");
mlir::Value zero;
if (inArithmeticIfContext)
- zero =
- realSelector
- ? builder->create<mlir::arith::ConstantOp>(
- loc, selectorType, builder->getFloatAttr(selectorType, 0.0))
- : builder->createIntegerConstant(loc, selectorType, 0);
+ zero = realSelector
+ ? mlir::arith::ConstantOp::create(
+ *builder, loc, selectorType,
+ builder->getFloatAttr(selectorType, 0.0))
+ : builder->createIntegerConstant(loc, selectorType, 0);
for (auto label : llvm::enumerate(labelList)) {
mlir::Value cond;
if (realSelector) // inArithmeticIfContext
- cond = builder->create<mlir::arith::CmpFOp>(
- loc,
+ cond = mlir::arith::CmpFOp::create(
+ *builder, loc,
label.index() == 0 ? mlir::arith::CmpFPredicate::OLT
: mlir::arith::CmpFPredicate::OGT,
selector, zero);
else if (inArithmeticIfContext) // INTEGER selector
- cond = builder->create<mlir::arith::CmpIOp>(
- loc,
+ cond = mlir::arith::CmpIOp::create(
+ *builder, loc,
label.index() == 0 ? mlir::arith::CmpIPredicate::slt
: mlir::arith::CmpIPredicate::sgt,
selector, zero);
else // A value of 0 is an IO ERR branch: invert comparison.
- cond = builder->create<mlir::arith::CmpIOp>(
- loc,
+ cond = mlir::arith::CmpIOp::create(
+ *builder, loc,
valueList[label.index()] == 0 ? mlir::arith::CmpIPredicate::ne
: mlir::arith::CmpIPredicate::eq,
selector,
@@ -1715,7 +1715,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
if (blockIsUnterminated()) {
bridge.openAccCtx().finalizeAndKeep();
bridge.fctCtx().finalizeAndKeep();
- builder->create<mlir::func::ReturnOp>(toLocation(), retval);
+ mlir::func::ReturnOp::create(*builder, toLocation(), retval);
}
if (!earlyReturn) {
bridge.openAccCtx().pop();
@@ -1795,7 +1795,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
if (mlir::Block *finalBlock = funit.finalBlock) {
// The current block must end with a terminator.
if (blockIsUnterminated())
- builder->create<mlir::cf::BranchOp>(toLocation(), finalBlock);
+ mlir::cf::BranchOp::create(*builder, toLocation(), finalBlock);
// Set insertion point to final block.
builder->setInsertionPoint(finalBlock, finalBlock->end());
}
@@ -1828,8 +1828,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
mlir::Value cond =
builder->createConvert(loc, builder->getI1Type(), condExpr);
if (negate)
- cond = builder->create<mlir::arith::XOrIOp>(
- loc, cond, builder->createIntegerConstant(loc, cond.getType(), 1));
+ cond = mlir::arith::XOrIOp::create(
+ *builder, loc, cond,
+ builder->createIntegerConstant(loc, cond.getType(), 1));
return cond;
}
@@ -1912,7 +1913,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
stmtCtx.finalizeAndReset();
// Raise an exception if REAL expr is a NaN.
if (mlir::isa<mlir::FloatType>(expr.getType()))
- expr = builder->create<mlir::arith::AddFOp>(toLocation(), expr, expr);
+ expr = mlir::arith::AddFOp::create(*builder, toLocation(), expr, expr);
// An empty valueList indicates to genMultiwayBranch that the branch is
// an ArithmeticIfStmt that has two branches on value 0 or 0.0.
llvm::SmallVector<int64_t> valueList;
@@ -2517,27 +2518,28 @@ class FirConverter : public Fortran::lower::AbstractConverter {
mlir::Value tripCount;
if (info.hasRealControl) {
auto diff1 =
- builder->create<mlir::arith::SubFOp>(loc, upperValue, lowerValue);
+ mlir::arith::SubFOp::create(*builder, loc, upperValue, lowerValue);
auto diff2 =
- builder->create<mlir::arith::AddFOp>(loc, diff1, stepValue);
- tripCount = builder->create<mlir::arith::DivFOp>(loc, diff2, stepValue);
+ mlir::arith::AddFOp::create(*builder, loc, diff1, stepValue);
+ tripCount =
+ mlir::arith::DivFOp::create(*builder, loc, diff2, stepValue);
tripCount =
builder->createConvert(loc, builder->getIndexType(), tripCount);
} else {
auto diff1 =
- builder->create<mlir::arith::SubIOp>(loc, upperValue, lowerValue);
+ mlir::arith::SubIOp::create(*builder, loc, upperValue, lowerValue);
auto diff2 =
- builder->create<mlir::arith::AddIOp>(loc, diff1, stepValue);
+ mlir::arith::AddIOp::create(*builder, loc, diff1, stepValue);
tripCount =
- builder->create<mlir::arith::DivSIOp>(loc, diff2, stepValue);
+ mlir::arith::DivSIOp::create(*builder, loc, diff2, stepValue);
}
if (forceLoopToExecuteOnce) { // minimum tripCount is 1
mlir::Value one =
builder->createIntegerConstant(loc, tripCount.getType(), 1);
- auto cond = builder->create<mlir::arith::CmpIOp>(
- loc, mlir::arith::CmpIPredicate::slt, tripCount, one);
+ auto cond = mlir::arith::CmpIOp::create(
+ *builder, loc, mlir::arith::CmpIPredicate::slt, tripCount, one);
tripCount =
- builder->create<mlir::arith::SelectOp>(loc, cond, one, tripCount);
+ mlir::arith::SelectOp::create(*builder, loc, cond, one, tripCount);
}
info.tripVariable = builder->createTemporary(loc, tripCount.getType());
fir::StoreOp::create(*builder, loc, tripCount, info.tripVariable);
@@ -2549,8 +2551,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
tripCount = fir::LoadOp::create(*builder, loc, info.tripVariable);
mlir::Value zero =
builder->createIntegerConstant(loc, tripCount.getType(), 0);
- auto cond = builder->create<mlir::arith::CmpIOp>(
- loc, mlir::arith::CmpIPredicate::sgt, tripCount, zero);
+ auto cond = mlir::arith::CmpIOp::create(
+ *builder, loc, mlir::arith::CmpIPredicate::sgt, tripCount, zero);
if (info.maskExpr) {
genConditionalBranch(cond, info.maskBlock, info.exitBlock);
startBlock(info.maskBlock);
@@ -2653,8 +2655,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
auto doLoopOp = mlir::cast<fir::DoLoopOp>(info.loopOp);
builder->setInsertionPointToEnd(doLoopOp.getBody());
llvm::SmallVector<mlir::Value, 2> results;
- results.push_back(builder->create<mlir::arith::AddIOp>(
- loc, doLoopOp.getInductionVar(), doLoopOp.getStep(), iofAttr));
+ results.push_back(mlir::arith::AddIOp::create(
+ *builder, loc, doLoopOp.getInductionVar(), doLoopOp.getStep(),
+ iofAttr));
// Step loopVariable to help optimizations such as vectorization.
// Induction variable elimination will clean up as necessary.
mlir::Value step = builder->createConvert(
@@ -2662,7 +2665,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
mlir::Value loopVar =
fir::LoadOp::create(*builder, loc, info.loopVariable);
results.push_back(
- builder->create<mlir::arith::AddIOp>(loc, loopVar, step, iofAttr));
+ mlir::arith::AddIOp::create(*builder, loc, loopVar, step, iofAttr));
fir::ResultOp::create(*builder, loc, results);
builder->setInsertionPointAfter(doLoopOp);
// The loop control variable may be used after the loop.
@@ -2676,7 +2679,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
fir::LoadOp::create(*builder, loc, info.tripVariable);
mlir::Value one =
builder->createIntegerConstant(loc, tripCount.getType(), 1);
- tripCount = builder->create<mlir::arith::SubIOp>(loc, tripCount, one);
+ tripCount = mlir::arith::SubIOp::create(*builder, loc, tripCount, one);
fir::StoreOp::create(*builder, loc, tripCount, info.tripVariable);
mlir::Value value = fir::LoadOp::create(*builder, loc, info.loopVariable);
mlir::Value step;
@@ -2685,9 +2688,10 @@ class FirConverter : public Fortran::lower::AbstractConverter {
else
step = genControlValue(info.stepExpr, info);
if (info.hasRealControl)
- value = builder->create<mlir::arith::AddFOp>(loc, value, step);
+ value = mlir::arith::AddFOp::create(*builder, loc, value, step);
else
- value = builder->create<mlir::arith::AddIOp>(loc, value, step, iofAttr);
+ value =
+ mlir::arith::AddIOp::create(*builder, loc, value, step, iofAttr);
fir::StoreOp::create(*builder, loc, value, info.loopVariable);
genBranch(info.headerBlock);
@@ -3184,8 +3188,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
assert(funit && "not inside main program, function or subroutine");
mlir::Block *continueBlock =
builder->getBlock()->splitBlock(builder->getBlock()->end());
- builder->create<mlir::cf::CondBranchOp>(toLocation(), exitCond,
- funit->finalBlock, continueBlock);
+ mlir::cf::CondBranchOp::create(*builder, toLocation(), exitCond,
+ funit->finalBlock, continueBlock);
builder->setInsertionPointToEnd(continueBlock);
}
}
@@ -3353,8 +3357,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
step = fir::getBase(
genExprValue(*Fortran::semantics::GetExpr(*expr), stmtCtx));
else
- step = builder->create<mlir::arith::ConstantIndexOp>(
- loc, 1); // Use index type directly
+ step = mlir::arith::ConstantIndexOp::create(
+ *builder, loc, 1); // Use index type directly
// Ensure lb, ub, and step are of index type using fir.convert
lb = fir::ConvertOp::create(*builder, loc, idxTy, lb);
@@ -3625,7 +3629,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
auto genCond = [&](mlir::Value rhs,
mlir::arith::CmpIPredicate pred) -> mlir::Value {
if (!isCharSelector)
- return builder->create<mlir::arith::CmpIOp>(loc, pred, selector, rhs);
+ return mlir::arith::CmpIOp::create(*builder, loc, pred, selector,
+ rhs);
fir::factory::CharacterExprHelper charHelper{*builder, loc};
std::pair<mlir::Value, mlir::Value> lhsVal =
charHelper.createUnboxChar(selector);
@@ -3840,9 +3845,9 @@ class FirConverter : public Fortran::lower::AbstractConverter {
mlir::Block *selectCaseBlock = insertBlock(blockList[0]);
mlir::Block *assumedSizeBlock =
rankStarBlock ? rankStarBlock : defaultBlock;
- builder->create<mlir::cf::CondBranchOp>(
- loc, isAssumedSize, assumedSizeBlock, mlir::ValueRange{},
- selectCaseBlock, mlir::ValueRange{});
+ mlir::cf::CondBranchOp::create(*builder, loc, isAssumedSize,
+ assumedSizeBlock, mlir::ValueRange{},
+ selectCaseBlock, mlir::ValueRange{});
startBlock(selectCaseBlock);
}
// Create fir.select_case for the other rank cases.
@@ -5631,7 +5636,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
if (Fortran::lower::isInOpenACCLoop(*builder))
Fortran::lower::genEarlyReturnInOpenACCLoop(*builder, loc);
else
- builder->create<mlir::cf::BranchOp>(loc, funit->finalBlock);
+ mlir::cf::BranchOp::create(*builder, loc, funit->finalBlock);
}
void genFIR(const Fortran::parser::CycleStmt &) {
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index d1efd8e8d2ca7..0a06d0a09727c 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -1566,8 +1566,8 @@ template <typename OpTy, typename... Args>
static OpTy genOpWithBody(const OpWithBodyGenInfo &info,
const ConstructQueue &queue,
ConstructQueue::const_iterator item, Args &&...args) {
- auto op = info.converter.getFirOpBuilder().create<OpTy>(
- info.loc, std::forward<Args>(args)...);
+ auto op = OpTy::create(info.converter.getFirOpBuilder(), info.loc,
+ std::forward<Args>(args)...);
createBodyOfOp(*op, info, queue, item);
return op;
}
@@ -1948,7 +1948,7 @@ genBarrierOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
semantics::SemanticsContext &semaCtx, lower::pft::Evaluation &eval,
mlir::Location loc, const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
- return converter.getFirOpBuilder().create<mlir::omp::BarrierOp>(loc);
+ return mlir::omp::BarrierOp::create(converter.getFirOpBuilder(), loc);
}
static mlir::omp::CancelOp genCancelOp(lower::AbstractConverter &converter,
@@ -1960,8 +1960,8 @@ static mlir::omp::CancelOp genCancelOp(lower::AbstractConverter &converter,
mlir::omp::CancelOperands clauseOps;
genCancelClauses(converter, semaCtx, item->clauses, loc, clauseOps);
- return converter.getFirOpBuilder().create<mlir::omp::CancelOp>(loc,
- clauseOps);
+ return mlir::omp::CancelOp::create(converter.getFirOpBuilder(), loc,
+ clauseOps);
}
static mlir::omp::CancellationPointOp genCancellationPointOp(
@@ -1972,8 +1972,8 @@ static mlir::omp::CancellationPointOp genCancellationPointOp(
genCancellationPointClauses(converter, semaCtx, item->clauses, loc,
clauseOps);
- return converter.getFirOpBuilder().create<mlir::omp::CancellationPointOp>(
- loc, clauseOps);
+ return mlir::omp::CancellationPointOp::create(converter.getFirOpBuilder(),
+ loc, clauseOps);
}
static mlir::omp::CriticalOp
@@ -2016,8 +2016,9 @@ genFlushOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
genFlushClauses(converter, semaCtx, objects, item->clauses, loc,
operandRange);
- return converter.getFirOpBuilder().create<mlir::omp::FlushOp>(
- converter.getCurrentLocation(), operandRange);
+ return mlir::omp::FlushOp::create(converter.getFirOpBuilder(),
+ converter.getCurrentLocation(),
+ operandRange);
}
static mlir::omp::LoopNestOp genLoopNestOp(
@@ -2135,36 +2136,37 @@ genCanonicalLoopOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// Start lowering
mlir::Value zero = firOpBuilder.createIntegerConstant(loc, loopVarType, 0);
mlir::Value one = firOpBuilder.createIntegerConstant(loc, loopVarType, 1);
- mlir::Value isDownwards = firOpBuilder.create<mlir::arith::CmpIOp>(
- loc, mlir::arith::CmpIPredicate::slt, loopStepVar, zero);
+ mlir::Value isDownwards = mlir::arith::CmpIOp::create(
+ firOpBuilder, loc, mlir::arith::CmpIPredicate::slt, loopStepVar, zero);
// Ensure we are counting upwards. If not, negate step and swap lb and ub.
mlir::Value negStep =
- firOpBuilder.create<mlir::arith::SubIOp>(loc, zero, loopStepVar);
- mlir::Value incr = firOpBuilder.create<mlir::arith::SelectOp>(
- loc, isDownwards, negStep, loopStepVar);
- mlir::Value lb = firOpBuilder.create<mlir::arith::SelectOp>(
- loc, isDownwards, loopUBVar, loopLBVar);
- mlir::Value ub = firOpBuilder.create<mlir::arith::SelectOp>(
- loc, isDownwards, loopLBVar, loopUBVar);
+ mlir::arith::SubIOp::create(firOpBuilder, loc, zero, loopStepVar);
+ mlir::Value incr = mlir::arith::SelectOp::create(
+ firOpBuilder, loc, isDownwards, negStep, loopStepVar);
+ mlir::Value lb = mlir::arith::SelectOp::create(firOpBuilder, loc, isDownwards,
+ loopUBVar, loopLBVar);
+ mlir::Value ub = mlir::arith::SelectOp::create(firOpBuilder, loc, isDownwards,
+ loopLBVar, loopUBVar);
// Compute the trip count assuming lb <= ub. This guarantees that the result
// is non-negative and we can use unsigned arithmetic.
- mlir::Value span = firOpBuilder.create<mlir::arith::SubIOp>(
- loc, ub, lb, ::mlir::arith::IntegerOverflowFlags::nuw);
+ mlir::Value span = mlir::arith::SubIOp::create(
+ firOpBuilder, loc, ub, lb, ::mlir::arith::IntegerOverflowFlags::nuw);
mlir::Value tcMinusOne =
- firOpBuilder.create<mlir::arith::DivUIOp>(loc, span, incr);
- mlir::Value tcIfLooping = firOpBuilder.create<mlir::arith::AddIOp>(
- loc, tcMinusOne, one, ::mlir::arith::IntegerOverflowFlags::nuw);
+ mlir::arith::DivUIOp::create(firOpBuilder, loc, span, incr);
+ mlir::Value tcIfLooping =
+ mlir::arith::AddIOp::create(firOpBuilder, loc, tcMinusOne, one,
+ ::mlir::arith::IntegerOverflowFlags::nuw);
// Fall back to 0 if lb > ub
- mlir::Value isZeroTC = firOpBuilder.create<mlir::arith::CmpIOp>(
- loc, mlir::arith::CmpIPredicate::slt, ub, lb);
- mlir::Value tripcount = firOpBuilder.create<mlir::arith::SelectOp>(
- loc, isZeroTC, zero, tcIfLooping);
+ mlir::Value isZeroTC = mlir::arith::CmpIOp::create(
+ firOpBuilder, loc, mlir::arith::CmpIPredicate::slt, ub, lb);
+ mlir::Value tripcount = mlir::arith::SelectOp::create(
+ firOpBuilder, loc, isZeroTC, zero, tcIfLooping);
// Create the CLI handle.
- auto newcli = firOpBuilder.create<mlir::omp::NewCliOp>(loc);
+ auto newcli = mlir::omp::NewCliOp::create(firOpBuilder, loc);
mlir::Value cli = newcli.getResult();
auto ivCallback = [&](mlir::Operation *op)
@@ -2177,9 +2179,9 @@ genCanonicalLoopOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
// Compute the value of the loop variable from the logical iteration number.
mlir::Value natIterNum = fir::getBase(region.front().getArgument(0));
mlir::Value scaled =
- firOpBuilder.create<mlir::arith::MulIOp>(loc, natIterNum, loopStepVar);
+ mlir::arith::MulIOp::create(firOpBuilder, loc, natIterNum, loopStepVar);
mlir::Value userVal =
- firOpBuilder.create<mlir::arith::AddIOp>(loc, loopLBVar, scaled);
+ mlir::arith::AddIOp::create(firOpBuilder, loc, loopLBVar, scaled);
// Write loop value to loop variable
mlir::Operation *storeOp = setLoopVar(converter, loc, userVal, iv);
@@ -2226,7 +2228,7 @@ static void genUnrollOp(Fortran::lower::AbstractConverter &converter,
// Apply unrolling to it
auto cli = canonLoop.getCli();
- firOpBuilder.create<mlir::omp::UnrollHeuristicOp>(loc, cli);
+ mlir::omp::UnrollHeuristicOp::create(firOpBuilder, loc, cli);
}
static mlir::omp::MaskedOp
@@ -2310,8 +2312,8 @@ genScanOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
const ConstructQueue &queue, ConstructQueue::const_iterator item) {
mlir::omp::ScanOperands clauseOps;
genScanClauses(converter, semaCtx, item->clauses, loc, clauseOps);
- return converter.getFirOpBuilder().create<mlir::omp::ScanOp>(
- converter.getCurrentLocation(), clauseOps);
+ return mlir::omp::ScanOp::create(converter.getFirOpBuilder(),
+ converter.getCurrentLocation(), clauseOps);
}
static mlir::omp::SectionsOp
@@ -2625,9 +2627,8 @@ static mlir::omp::TargetDataOp genTargetDataOp(
genTargetDataClauses(converter, semaCtx, stmtCtx, item->clauses, loc,
clauseOps, useDeviceAddrSyms, useDevicePtrSyms);
- auto targetDataOp =
- converter.getFirOpBuilder().create<mlir::omp::TargetDataOp>(loc,
- clauseOps);
+ auto targetDataOp = mlir::omp::TargetDataOp::create(
+ converter.getFirOpBuilder(), loc, clauseOps);
llvm::SmallVector<mlir::Value> useDeviceAddrBaseValues,
useDevicePtrBaseValues;
@@ -2741,8 +2742,8 @@ genTaskwaitOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
ConstructQueue::const_iterator item) {
mlir::omp::TaskwaitOperands clauseOps;
genTaskwaitClauses(converter, semaCtx, item->clauses, loc, clauseOps);
- return converter.getFirOpBuilder().create<mlir::omp::TaskwaitOp>(loc,
- clauseOps);
+ return mlir::omp::TaskwaitOp::create(converter.getFirOpBuilder(), loc,
+ clauseOps);
}
static mlir::omp::TaskyieldOp
@@ -2751,7 +2752,7 @@ genTaskyieldOp(lower::AbstractConverter &converter, lower::SymMap &symTable,
lower::pft::Evaluation &eval, mlir::Location loc,
const ConstructQueue &queue,
ConstructQueue::const_iterator item) {
- return converter.getFirOpBuilder().create<mlir::omp::TaskyieldOp>(loc);
+ return mlir::omp::TaskyieldOp::create(converter.getFirOpBuilder(), loc);
}
static mlir::omp::WorkshareOp genWorkshareOp(
diff --git a/flang/lib/Optimizer/Builder/FIRBuilder.cpp b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
index d1925c3602848..87a52ffc339f4 100644
--- a/flang/lib/Optimizer/Builder/FIRBuilder.cpp
+++ b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
@@ -147,7 +147,8 @@ mlir::Value fir::FirOpBuilder::createIntegerConstant(mlir::Location loc,
assert((cst >= 0 || mlir::isa<mlir::IndexType>(ty) ||
mlir::cast<mlir::IntegerType>(ty).getWidth() <= 64) &&
"must use APint");
- return create<mlir::arith::ConstantOp>(loc, ty, getIntegerAttr(ty, cst));
+ return mlir::arith::ConstantOp::create(*this, loc, ty,
+ getIntegerAttr(ty, cst));
}
mlir::Value fir::FirOpBuilder::createAllOnesInteger(mlir::Location loc,
@@ -156,7 +157,8 @@ mlir::Value fir::FirOpBuilder::createAllOnesInteger(mlir::Location loc,
return createIntegerConstant(loc, ty, -1);
llvm::APInt allOnes =
llvm::APInt::getAllOnes(mlir::cast<mlir::IntegerType>(ty).getWidth());
- return create<mlir::arith::ConstantOp>(loc, ty, getIntegerAttr(ty, allOnes));
+ return mlir::arith::ConstantOp::create(*this, loc, ty,
+ getIntegerAttr(ty, allOnes));
}
mlir::Value
@@ -185,7 +187,7 @@ mlir::Value fir::FirOpBuilder::createRealConstant(mlir::Location loc,
const llvm::APFloat &value) {
if (mlir::isa<mlir::FloatType>(fltTy)) {
auto attr = getFloatAttr(fltTy, value);
- return create<mlir::arith::ConstantOp>(loc, fltTy, attr);
+ return mlir::arith::ConstantOp::create(*this, loc, fltTy, attr);
}
llvm_unreachable("should use builtin floating-point type");
}
@@ -418,12 +420,12 @@ mlir::Value fir::FirOpBuilder::genTempDeclareOp(
mlir::Value fir::FirOpBuilder::genStackSave(mlir::Location loc) {
mlir::Type voidPtr = mlir::LLVM::LLVMPointerType::get(
getContext(), fir::factory::getAllocaAddressSpace(&getDataLayout()));
- return create<mlir::LLVM::StackSaveOp>(loc, voidPtr);
+ return mlir::LLVM::StackSaveOp::create(*this, loc, voidPtr);
}
void fir::FirOpBuilder::genStackRestore(mlir::Location loc,
mlir::Value stackPointer) {
- create<mlir::LLVM::StackRestoreOp>(loc, stackPointer);
+ mlir::LLVM::StackRestoreOp::create(*this, loc, stackPointer);
}
/// Create a global variable in the (read-only) data section. A global variable
@@ -701,8 +703,8 @@ mlir::Value fir::FirOpBuilder::createSlice(mlir::Location loc,
for (auto [lbnd, extent] : llvm::zip(lbounds, extents)) {
auto lb = createConvert(loc, idxTy, lbnd);
auto ext = createConvert(loc, idxTy, extent);
- auto shift = create<mlir::arith::SubIOp>(loc, lb, one);
- auto ub = create<mlir::arith::AddIOp>(loc, ext, shift);
+ auto shift = mlir::arith::SubIOp::create(*this, loc, lb, one);
+ auto ub = mlir::arith::AddIOp::create(*this, loc, ext, shift);
trips.push_back(lb);
trips.push_back(ub);
trips.push_back(one);
@@ -852,12 +854,12 @@ mlir::Value fir::FirOpBuilder::genExtentFromTriplet(mlir::Location loc,
lb = createConvert(loc, type, lb);
ub = createConvert(loc, type, ub);
step = createConvert(loc, type, step);
- auto diff = create<mlir::arith::SubIOp>(loc, ub, lb);
- auto add = create<mlir::arith::AddIOp>(loc, diff, step);
- auto div = create<mlir::arith::DivSIOp>(loc, add, step);
- auto cmp = create<mlir::arith::CmpIOp>(loc, mlir::arith::CmpIPredicate::sgt,
- div, zero);
- return create<mlir::arith::SelectOp>(loc, cmp, div, zero);
+ auto diff = mlir::arith::SubIOp::create(*this, loc, ub, lb);
+ auto add = mlir::arith::AddIOp::create(*this, loc, diff, step);
+ auto div = mlir::arith::DivSIOp::create(*this, loc, add, step);
+ auto cmp = mlir::arith::CmpIOp::create(
+ *this, loc, mlir::arith::CmpIPredicate::sgt, div, zero);
+ return mlir::arith::SelectOp::create(*this, loc, cmp, div, zero);
}
mlir::Value fir::FirOpBuilder::genAbsentOp(mlir::Location loc,
diff --git a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
index dec59ef159b76..bfa470dd5690d 100644
--- a/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
+++ b/flang/lib/Optimizer/Builder/IntrinsicCall.cpp
@@ -2413,14 +2413,14 @@ mlir::func::FuncOp IntrinsicLibrary::getWrapper(GeneratorType generator,
if constexpr (std::is_same_v<GeneratorType, SubroutineGenerator>) {
localLib.invokeGenerator(generator, localArguments);
- localBuilder->create<mlir::func::ReturnOp>(localLoc);
+ mlir::func::ReturnOp::create(*localBuilder, localLoc);
} else {
assert(funcType.getNumResults() == 1 &&
"expect one result for intrinsic function wrapper type");
mlir::Type resultType = funcType.getResult(0);
auto result =
localLib.invokeGenerator(generator, resultType, localArguments);
- localBuilder->create<mlir::func::ReturnOp>(localLoc, result);
+ mlir::func::ReturnOp::create(*localBuilder, localLoc, result);
}
} else {
// Wrapper was already built, ensure it has the sought type
@@ -6662,9 +6662,8 @@ IntrinsicLibrary::genMatchAllSync(mlir::Type resultType,
mlir::Type retTy =
mlir::LLVM::LLVMStructType::getLiteral(context, {resultType, i1Ty});
auto match =
- builder
- .create<mlir::NVVM::MatchSyncOp>(loc, retTy, args[0], arg1,
- mlir::NVVM::MatchSyncKind::all)
+ mlir::NVVM::MatchSyncOp::create(builder, loc, retTy, args[0], arg1,
+ mlir::NVVM::MatchSyncKind::all)
.getResult();
auto value = mlir::LLVM::ExtractValueOp::create(builder, loc, match, 0);
auto pred = mlir::LLVM::ExtractValueOp::create(builder, loc, match, 1);
@@ -6701,9 +6700,8 @@ IntrinsicLibrary::genMatchAnySync(mlir::Type resultType,
arg1 = fir::ConvertOp::create(
builder, loc, is32 ? builder.getI32Type() : builder.getI64Type(), arg1);
- return builder
- .create<mlir::NVVM::MatchSyncOp>(loc, resultType, args[0], arg1,
- mlir::NVVM::MatchSyncKind::any)
+ return mlir::NVVM::MatchSyncOp::create(builder, loc, resultType, args[0],
+ arg1, mlir::NVVM::MatchSyncKind::any)
.getResult();
}
@@ -8142,7 +8140,7 @@ mlir::Value IntrinsicLibrary::genSinpi(mlir::Type resultType,
mlir::Value dfactor =
builder.createRealConstant(loc, mlir::Float64Type::get(context), pi);
mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
- mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
+ mlir::Value arg = mlir::arith::MulFOp::create(builder, loc, args[0], factor);
return getRuntimeCallGenerator("sin", ftype)(builder, loc, {arg});
}
@@ -8239,7 +8237,7 @@ mlir::Value IntrinsicLibrary::genTanpi(mlir::Type resultType,
mlir::Value dfactor =
builder.createRealConstant(loc, mlir::Float64Type::get(context), pi);
mlir::Value factor = builder.createConvert(loc, args[0].getType(), dfactor);
- mlir::Value arg = builder.create<mlir::arith::MulFOp>(loc, args[0], factor);
+ mlir::Value arg = mlir::arith::MulFOp::create(builder, loc, args[0], factor);
return getRuntimeCallGenerator("tan", ftype)(builder, loc, {arg});
}
diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
index 1362a9f2bfdfd..1b289ae690cbe 100644
--- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp
+++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
@@ -1335,19 +1335,19 @@ genCUFAllocDescriptor(mlir::Location loc,
RTNAME_STRING(CUFAllocDescriptor));
auto funcFunc =
mod.lookupSymbol<mlir::func::FuncOp>(RTNAME_STRING(CUFAllocDescriptor));
- if (!llvmFunc && !funcFunc)
- mlir::OpBuilder::atBlockEnd(mod.getBody())
- .create<mlir::LLVM::LLVMFuncOp>(loc, RTNAME_STRING(CUFAllocDescriptor),
- fctTy);
+ if (!llvmFunc && !funcFunc) {
+ auto builder = mlir::OpBuilder::atBlockEnd(mod.getBody());
+ mlir::LLVM::LLVMFuncOp::create(builder, loc,
+ RTNAME_STRING(CUFAllocDescriptor), fctTy);
+ }
mlir::Type structTy = typeConverter.convertBoxTypeAsStruct(boxTy);
std::size_t boxSize = dl->getTypeSizeInBits(structTy) / 8;
mlir::Value sizeInBytes =
genConstantIndex(loc, llvmIntPtrType, rewriter, boxSize);
llvm::SmallVector args = {sizeInBytes, sourceFile, sourceLine};
- return rewriter
- .create<mlir::LLVM::CallOp>(loc, fctTy, RTNAME_STRING(CUFAllocDescriptor),
- args)
+ return mlir::LLVM::CallOp::create(rewriter, loc, fctTy,
+ RTNAME_STRING(CUFAllocDescriptor), args)
.getResult();
}
diff --git a/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp b/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp
index 68f9d4115a981..fa935542d40f7 100644
--- a/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp
+++ b/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp
@@ -520,10 +520,10 @@ class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
llvm::SmallVector<mlir::Value, 1> newCallResults;
// TODO propagate/update call argument and result attributes.
if constexpr (std::is_same_v<std::decay_t<A>, mlir::gpu::LaunchFuncOp>) {
- auto newCall = rewriter->create<A>(
- loc, callOp.getKernel(), callOp.getGridSizeOperandValues(),
- callOp.getBlockSizeOperandValues(),
- callOp.getDynamicSharedMemorySize(), newOpers);
+ auto newCall = A::create(*rewriter, loc, callOp.getKernel(),
+ callOp.getGridSizeOperandValues(),
+ callOp.getBlockSizeOperandValues(),
+ callOp.getDynamicSharedMemorySize(), newOpers);
if (callOp.getClusterSizeX())
newCall.getClusterSizeXMutable().assign(callOp.getClusterSizeX());
if (callOp.getClusterSizeY())
@@ -585,9 +585,10 @@ class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
else
newCallResults.append(newCall.result_begin(), newCall.result_end());
} else {
- fir::DispatchOp dispatchOp = rewriter->create<A>(
- loc, newResTys, rewriter->getStringAttr(callOp.getMethod()),
- callOp.getOperands()[0], newOpers,
+ fir::DispatchOp dispatchOp = A::create(
+ *rewriter, loc, newResTys,
+ rewriter->getStringAttr(callOp.getMethod()), callOp.getOperands()[0],
+ newOpers,
rewriter->getI32IntegerAttr(*callOp.getPassArgPos() + passArgShift),
/*arg_attrs=*/nullptr, /*res_attrs=*/nullptr,
callOp.getProcedureAttrsAttr());
@@ -1056,7 +1057,7 @@ class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
auto cast =
fir::ConvertOp::create(*rewriter, loc, oldOperTy, newArg);
fir::StoreOp::create(*rewriter, loc, oldOper, cast);
- rewriter->create<ReturnOpTy>(loc);
+ ReturnOpTy::create(*rewriter, loc);
ret.erase();
});
} break;
@@ -1069,7 +1070,7 @@ class TargetRewrite : public fir::impl::TargetRewritePassBase<TargetRewrite> {
mlir::Value bitcast =
convertValueInMemory(loc, oldOper, newResTys[fixup.index],
/*inputMayBeBigger=*/false);
- rewriter->create<ReturnOpTy>(loc, bitcast);
+ ReturnOpTy::create(*rewriter, loc, bitcast);
ret.erase();
});
} break;
diff --git a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
index df1411a894373..95f01e0a9ab6f 100644
--- a/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
+++ b/flang/unittests/Optimizer/Builder/HLFIRToolsTest.cpp
@@ -43,8 +43,8 @@ struct HLFIRToolsTest : public testing::Test {
mlir::Value createConstant(std::int64_t cst) {
mlir::Type indexType = firBuilder->getIndexType();
- return firBuilder->create<mlir::arith::ConstantOp>(
- getLoc(), indexType, firBuilder->getIntegerAttr(indexType, cst));
+ return mlir::arith::ConstantOp::create(*firBuilder, getLoc(), indexType,
+ firBuilder->getIntegerAttr(indexType, cst));
}
mlir::Location getLoc() { return firBuilder->getUnknownLoc(); }
diff --git a/flang/unittests/Optimizer/FortranVariableTest.cpp b/flang/unittests/Optimizer/FortranVariableTest.cpp
index 94537edc6082a..f194eb7489df4 100644
--- a/flang/unittests/Optimizer/FortranVariableTest.cpp
+++ b/flang/unittests/Optimizer/FortranVariableTest.cpp
@@ -19,10 +19,10 @@ struct FortranVariableTest : public testing::Test {
// Set up a Module with a dummy function operation inside.
// Set the insertion point in the function entry block.
- moduleOp = builder->create<mlir::ModuleOp>(loc);
+ moduleOp = mlir::ModuleOp::create(*builder, loc);
builder->setInsertionPointToStart(moduleOp->getBody());
- mlir::func::FuncOp func = builder->create<mlir::func::FuncOp>(
- loc, "fortran_variable_tests", builder->getFunctionType({}, {}));
+ mlir::func::FuncOp func = mlir::func::FuncOp::create(*builder, loc,
+ "fortran_variable_tests", builder->getFunctionType({}, {}));
auto *entryBlock = func.addEntryBlock();
builder->setInsertionPointToStart(entryBlock);
}
@@ -30,8 +30,8 @@ struct FortranVariableTest : public testing::Test {
mlir::Location getLoc() { return builder->getUnknownLoc(); }
mlir::Value createConstant(std::int64_t cst) {
mlir::Type indexType = builder->getIndexType();
- return builder->create<mlir::arith::ConstantOp>(
- getLoc(), indexType, builder->getIntegerAttr(indexType, cst));
+ return mlir::arith::ConstantOp::create(
+ *builder, getLoc(), indexType, builder->getIntegerAttr(indexType, cst));
}
mlir::Value createShape(llvm::ArrayRef<mlir::Value> extents) {
More information about the flang-commits
mailing list