aboutsummaryrefslogtreecommitdiff
path: root/flang/lib/Lower/ConvertCall.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'flang/lib/Lower/ConvertCall.cpp')
-rw-r--r--flang/lib/Lower/ConvertCall.cpp154
1 files changed, 78 insertions, 76 deletions
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index 0715133..8c3648b 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -85,7 +85,7 @@ static mlir::Value genRecordCPtrValueArg(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Value rec,
mlir::Type ty) {
mlir::Value cAddr = fir::factory::genCPtrOrCFunptrAddr(builder, loc, rec, ty);
- mlir::Value cVal = builder.create<fir::LoadOp>(loc, cAddr);
+ mlir::Value cVal = fir::LoadOp::create(builder, loc, cAddr);
return builder.createConvert(loc, cAddr.getType(), cVal);
}
@@ -159,8 +159,8 @@ static mlir::Value readDim3Value(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Type refI32Ty = fir::ReferenceType::get(i32Ty);
llvm::SmallVector<mlir::Value> lenParams;
- mlir::Value designate = builder.create<hlfir::DesignateOp>(
- loc, refI32Ty, dim3Addr, /*component=*/comp,
+ mlir::Value designate = hlfir::DesignateOp::create(
+ builder, loc, refI32Ty, dim3Addr, /*component=*/comp,
/*componentShape=*/mlir::Value{}, hlfir::DesignateOp::Subscripts{},
/*substring=*/mlir::ValueRange{}, /*complexPartAttr=*/std::nullopt,
mlir::Value{}, lenParams);
@@ -229,8 +229,8 @@ static mlir::Value remapActualToDummyDescriptor(
if (fir::isPolymorphicType(dummyBoxType))
mold = explicitArgument;
mlir::Value remapped =
- builder.create<fir::EmboxOp>(loc, dummyBoxType, baseAddr, shape,
- /*slice=*/mlir::Value{}, lengths, mold);
+ fir::EmboxOp::create(builder, loc, dummyBoxType, baseAddr, shape,
+ /*slice=*/mlir::Value{}, lengths, mold);
if (mapSymbols)
symMap.popScope();
return remapped;
@@ -273,12 +273,12 @@ static void remapActualToDummyDescriptors(
mlir::Value newBox = remapActualToDummyDescriptor(
loc, converter, symMap, argLambdaCapture, caller,
isBindcCall);
- builder.create<fir::ResultOp>(loc, newBox);
+ fir::ResultOp::create(builder, loc, newBox);
})
.genElse([&]() {
mlir::Value absent =
- builder.create<fir::AbsentOp>(loc, dummyType);
- builder.create<fir::ResultOp>(loc, absent);
+ fir::AbsentOp::create(builder, loc, dummyType);
+ fir::ResultOp::create(builder, loc, absent);
})
.getResults()[0];
caller.placeInput(arg, remapped);
@@ -381,8 +381,8 @@ Fortran::lower::genCallOpAndResult(
if (isExprCall) {
mlir::Type exprType = hlfir::getExprType(type);
- evaluateInMemory = builder.create<hlfir::EvaluateInMemoryOp>(
- loc, exprType, arrayResultShape, resultLengths);
+ evaluateInMemory = hlfir::EvaluateInMemoryOp::create(
+ builder, loc, exprType, arrayResultShape, resultLengths);
builder.setInsertionPointToStart(&evaluateInMemory.getBody().front());
return toExtendedValue(loc, evaluateInMemory.getMemory(), extents,
lengths);
@@ -454,7 +454,7 @@ Fortran::lower::genCallOpAndResult(
if (!addHostAssociations &&
mustCastFuncOpToCopeWithImplicitInterfaceMismatch(
loc, converter, callSiteType, funcOpType))
- funcPointer = builder.create<fir::AddrOfOp>(loc, funcOpType, symbolAttr);
+ funcPointer = fir::AddrOfOp::create(builder, loc, funcOpType, symbolAttr);
else
funcSymbolAttr = symbolAttr;
@@ -482,7 +482,7 @@ Fortran::lower::genCallOpAndResult(
if (funcPointer) {
operands.push_back(
mlir::isa<fir::BoxProcType>(funcPointer.getType())
- ? builder.create<fir::BoxAddrOp>(loc, funcType, funcPointer)
+ ? fir::BoxAddrOp::create(builder, loc, funcType, funcPointer)
: builder.createConvert(loc, funcType, funcPointer));
}
@@ -499,10 +499,10 @@ Fortran::lower::genCallOpAndResult(
auto funcTy = mlir::FunctionType::get(context, {}, {});
auto boxProcTy = builder.getBoxProcType(funcTy);
if (mlir::Value host = argumentHostAssocs(converter, fst)) {
- cast = builder.create<fir::EmboxProcOp>(
- loc, boxProcTy, llvm::ArrayRef<mlir::Value>{fst, host});
+ cast = fir::EmboxProcOp::create(builder, loc, boxProcTy,
+ llvm::ArrayRef<mlir::Value>{fst, host});
} else {
- cast = builder.create<fir::EmboxProcOp>(loc, boxProcTy, fst);
+ cast = fir::EmboxProcOp::create(builder, loc, boxProcTy, fst);
}
} else {
mlir::Type fromTy = fir::unwrapRefType(fst.getType());
@@ -613,10 +613,10 @@ Fortran::lower::genCallOpAndResult(
stream = fir::getBase(converter.genExprAddr(
caller.getCallDescription().chevrons()[3], stmtCtx));
- builder.create<cuf::KernelLaunchOp>(
- loc, funcType.getResults(), funcSymbolAttr, grid_x, grid_y, grid_z,
- block_x, block_y, block_z, bytes, stream, operands,
- /*arg_attrs=*/nullptr, /*res_attrs=*/nullptr);
+ cuf::KernelLaunchOp::create(builder, loc, funcType.getResults(),
+ funcSymbolAttr, grid_x, grid_y, grid_z, block_x,
+ block_y, block_z, bytes, stream, operands,
+ /*arg_attrs=*/nullptr, /*res_attrs=*/nullptr);
callNumResults = 0;
} else if (caller.requireDispatchCall()) {
// Procedure call requiring a dynamic dispatch. Call is created with
@@ -640,8 +640,8 @@ Fortran::lower::genCallOpAndResult(
// passed object because interface mismatch issues may have inserted a
// cast to the operand with a different declared type, which would break
// later type bound call resolution in the FIR to FIR pass.
- dispatch = builder.create<fir::DispatchOp>(
- loc, funcType.getResults(), builder.getStringAttr(procName),
+ dispatch = fir::DispatchOp::create(
+ builder, loc, funcType.getResults(), builder.getStringAttr(procName),
caller.getInputs()[*passArg], operands,
builder.getI32IntegerAttr(*passArg), /*arg_attrs=*/nullptr,
/*res_attrs=*/nullptr, procAttrs);
@@ -656,9 +656,9 @@ Fortran::lower::genCallOpAndResult(
mlir::Value passObject = fir::getBase(dataRefValue);
if (fir::isa_ref_type(passObject.getType()))
- passObject = builder.create<fir::LoadOp>(loc, passObject);
- dispatch = builder.create<fir::DispatchOp>(
- loc, funcType.getResults(), builder.getStringAttr(procName),
+ passObject = fir::LoadOp::create(builder, loc, passObject);
+ dispatch = fir::DispatchOp::create(
+ builder, loc, funcType.getResults(), builder.getStringAttr(procName),
passObject, operands, nullptr, /*arg_attrs=*/nullptr,
/*res_attrs=*/nullptr, procAttrs);
}
@@ -667,8 +667,8 @@ Fortran::lower::genCallOpAndResult(
callResult = dispatch.getResult(0);
} else {
// Standard procedure call with fir.call.
- auto call = builder.create<fir::CallOp>(
- loc, funcType.getResults(), funcSymbolAttr, operands,
+ auto call = fir::CallOp::create(
+ builder, loc, funcType.getResults(), funcSymbolAttr, operands,
/*arg_attrs=*/nullptr, /*res_attrs=*/nullptr, procAttrs);
callNumResults = call.getNumResults();
@@ -691,9 +691,9 @@ Fortran::lower::genCallOpAndResult(
if (caller.mustSaveResult()) {
assert(allocatedResult.has_value());
- builder.create<fir::SaveResultOp>(loc, callResult,
- fir::getBase(*allocatedResult),
- arrayResultShape, resultLengths);
+ fir::SaveResultOp::create(builder, loc, callResult,
+ fir::getBase(*allocatedResult), arrayResultShape,
+ resultLengths);
}
if (evaluateInMemory) {
@@ -864,9 +864,9 @@ static hlfir::EntityWithAttributes genStmtFunctionRef(
// The result must not be a variable.
result = hlfir::loadTrivialScalar(loc, builder, result);
if (result.isVariable())
- result = hlfir::Entity{builder.create<hlfir::AsExprOp>(loc, result)};
+ result = hlfir::Entity{hlfir::AsExprOp::create(builder, loc, result)};
for (auto associate : exprAssociations)
- builder.create<hlfir::EndAssociateOp>(loc, associate);
+ hlfir::EndAssociateOp::create(builder, loc, associate);
return hlfir::EntityWithAttributes{result};
}
@@ -951,9 +951,9 @@ extendedValueToHlfirEntity(mlir::Location loc, fir::FirOpBuilder &builder,
// rid of the memory indirection in a = char(b), so there is
// little incentive to increase the compiler complexity.
hlfir::Entity storage{builder.createTemporary(loc, charTy)};
- builder.create<fir::StoreOp>(loc, firBase, storage);
- auto asExpr = builder.create<hlfir::AsExprOp>(
- loc, storage, /*mustFree=*/builder.createBool(loc, false));
+ fir::StoreOp::create(builder, loc, firBase, storage);
+ auto asExpr = hlfir::AsExprOp::create(
+ builder, loc, storage, /*mustFree=*/builder.createBool(loc, false));
return hlfir::EntityWithAttributes{asExpr.getResult()};
}
return hlfir::genDeclare(loc, builder, exv, name,
@@ -965,7 +965,7 @@ namespace {
struct CallCleanUp {
struct CopyIn {
void genCleanUp(mlir::Location loc, fir::FirOpBuilder &builder) {
- builder.create<hlfir::CopyOutOp>(loc, tempBox, wasCopied, copyBackVar);
+ hlfir::CopyOutOp::create(builder, loc, tempBox, wasCopied, copyBackVar);
}
// address of the descriptor holding the temp if a temp was created.
mlir::Value tempBox;
@@ -976,7 +976,7 @@ struct CallCleanUp {
};
struct ExprAssociate {
void genCleanUp(mlir::Location loc, fir::FirOpBuilder &builder) {
- builder.create<hlfir::EndAssociateOp>(loc, tempVar, mustFree);
+ hlfir::EndAssociateOp::create(builder, loc, tempVar, mustFree);
}
mlir::Value tempVar;
mlir::Value mustFree;
@@ -1074,7 +1074,7 @@ struct ConditionallyPreparedDummy {
/// Generate the "fir.result %preparedDummy" in the then branch of the
/// wrapping fir.if.
void genThenResult(mlir::Location loc, fir::FirOpBuilder &builder) const {
- builder.create<fir::ResultOp>(loc, thenResultValues);
+ fir::ResultOp::create(builder, loc, thenResultValues);
}
/// Generate the "fir.result %absent" in the else branch of the
@@ -1089,7 +1089,7 @@ struct ConditionallyPreparedDummy {
else
elseResultValues.push_back(builder.genAbsentOp(loc, type));
}
- builder.create<fir::ResultOp>(loc, elseResultValues);
+ fir::ResultOp::create(builder, loc, elseResultValues);
}
/// Once the fir.if has been created, get the resulting %conditionallyPrepared
@@ -1134,7 +1134,7 @@ static hlfir::Entity fixProcedureDummyMismatch(mlir::Location loc,
if (mlir::isa<fir::BoxProcType>(actual.getType()) &&
fir::isCharacterProcedureTuple(dummyType)) {
mlir::Value length =
- builder.create<fir::UndefOp>(loc, builder.getCharacterLengthType());
+ fir::UndefOp::create(builder, loc, builder.getCharacterLengthType());
mlir::Value tuple = fir::factory::createCharacterProcedureTuple(
builder, loc, dummyType, actual, length);
return hlfir::Entity{tuple};
@@ -1317,8 +1317,8 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
mlir::Type tempBoxType = baseBoxTy.getBoxTypeWithNewAttr(
fir::BaseBoxType::Attribute::Allocatable);
mlir::Value tempBox = builder.createTemporary(loc, tempBoxType);
- auto copyIn = builder.create<hlfir::CopyInOp>(
- loc, var, tempBox, /*var_is_present=*/mlir::Value{});
+ auto copyIn = hlfir::CopyInOp::create(builder, loc, var, tempBox,
+ /*var_is_present=*/mlir::Value{});
// Register the copy-out after the call.
preparedDummy.pushCopyInCleanUp(copyIn.getTempBox(), copyIn.getWasCopied(),
doCopyOut ? copyIn.getVar()
@@ -1330,16 +1330,17 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
fir::BaseBoxType boxType = fir::BoxType::get(
hlfir::getFortranElementOrSequenceType(dummyTypeWithActualRank));
if (actualIsAssumedRank)
- return hlfir::Entity{builder.create<fir::ReboxAssumedRankOp>(
- loc, boxType, var, fir::LowerBoundModifierAttribute::SetToOnes)};
+ return hlfir::Entity{fir::ReboxAssumedRankOp::create(
+ builder, loc, boxType, var,
+ fir::LowerBoundModifierAttribute::SetToOnes)};
// Use actual shape when creating descriptor with dummy type, the dummy
// shape may be unknown in case of sequence association.
mlir::Type actualTy =
hlfir::getFortranElementOrSequenceType(actual.getType());
boxType = boxType.getBoxTypeWithNewShape(actualTy);
- return hlfir::Entity{builder.create<fir::ReboxOp>(loc, boxType, var,
- /*shape=*/mlir::Value{},
- /*slice=*/mlir::Value{})};
+ return hlfir::Entity{fir::ReboxOp::create(builder, loc, boxType, var,
+ /*shape=*/mlir::Value{},
+ /*slice=*/mlir::Value{})};
};
// Step 2: prepare the storage for the dummy arguments, ensuring that it
@@ -1361,7 +1362,7 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
// generated writes in copy-out.
isParameterObjectOrSubObject(entity)) {
// Make a copy in a temporary.
- auto copy = builder.create<hlfir::AsExprOp>(loc, entity);
+ auto copy = hlfir::AsExprOp::create(builder, loc, entity);
mlir::Type storageType = entity.getType();
mlir::NamedAttribute byRefAttr = fir::getAdaptToByRefAttr(builder);
hlfir::AssociateOp associate = hlfir::genAssociateExpr(
@@ -1441,14 +1442,14 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
auto lbModifier = needsZeroLowerBounds
? fir::LowerBoundModifierAttribute::SetToZeroes
: fir::LowerBoundModifierAttribute::SetToOnes;
- entity = hlfir::Entity{builder.create<fir::ReboxAssumedRankOp>(
- loc, dummyTypeWithActualRank, entity, lbModifier)};
+ entity = hlfir::Entity{fir::ReboxAssumedRankOp::create(
+ builder, loc, dummyTypeWithActualRank, entity, lbModifier)};
} else {
mlir::Value shift{};
if (needsZeroLowerBounds)
shift = getZeroLowerBounds(loc, builder, entity);
- entity = hlfir::Entity{builder.create<fir::ReboxOp>(
- loc, dummyTypeWithActualRank, entity, /*shape=*/shift,
+ entity = hlfir::Entity{fir::ReboxOp::create(
+ builder, loc, dummyTypeWithActualRank, entity, /*shape=*/shift,
/*slice=*/mlir::Value{})};
}
}
@@ -1501,8 +1502,8 @@ static PreparedDummyArgument prepareUserCallActualArgument(
// for this unusual if/then/else generation is that the number
// and types of the if results will depend on how the argument
// is prepared, and forecasting that here would be brittle.
- auto badIfOp = builder.create<fir::IfOp>(loc, dummyType, isPresent,
- /*withElseRegion=*/false);
+ auto badIfOp = fir::IfOp::create(builder, loc, dummyType, isPresent,
+ /*withElseRegion=*/false);
mlir::Block *preparationBlock = &badIfOp.getThenRegion().front();
builder.setInsertionPointToStart(preparationBlock);
PreparedDummyArgument unconditionalDummy =
@@ -1520,9 +1521,9 @@ static PreparedDummyArgument prepareUserCallActualArgument(
// badIfOp cannot be modified and used here).
llvm::SmallVector<mlir::Type> ifOpResultTypes;
ConditionallyPreparedDummy conditionalDummy(unconditionalDummy);
- auto ifOp = builder.create<fir::IfOp>(loc, conditionalDummy.getIfResulTypes(),
- isPresent,
- /*withElseRegion=*/true);
+ auto ifOp = fir::IfOp::create(builder, loc,
+ conditionalDummy.getIfResulTypes(), isPresent,
+ /*withElseRegion=*/true);
// Move "preparationBlock" into the "then" of the new
// fir.if operation and create fir.result propagating
// unconditionalDummy.
@@ -1559,7 +1560,7 @@ static PreparedDummyArgument prepareProcedurePointerActualArgument(
auto tempBoxProc{builder.createTemporary(loc, boxTy)};
hlfir::Entity nullBoxProc(
fir::factory::createNullBoxProc(builder, loc, boxTy));
- builder.create<fir::StoreOp>(loc, nullBoxProc, tempBoxProc);
+ fir::StoreOp::create(builder, loc, nullBoxProc, tempBoxProc);
return PreparedDummyArgument{tempBoxProc, /*cleanups=*/{}};
}
hlfir::Entity actual = preparedActual.getActual(loc, builder);
@@ -1568,7 +1569,7 @@ static PreparedDummyArgument prepareProcedurePointerActualArgument(
assert(actual.isProcedure());
// Procedure actual to procedure pointer dummy.
auto tempBoxProc{builder.createTemporary(loc, actual.getType())};
- builder.create<fir::StoreOp>(loc, actual, tempBoxProc);
+ fir::StoreOp::create(builder, loc, actual, tempBoxProc);
return PreparedDummyArgument{tempBoxProc, /*cleanups=*/{}};
}
@@ -1607,7 +1608,7 @@ void prepareUserCallArguments(
"adapt.cptrbyval");
value = hlfir::Entity{genRecordCPtrValueArg(
builder, loc, associate.getFirBase(), eleTy)};
- builder.create<hlfir::EndAssociateOp>(loc, associate);
+ hlfir::EndAssociateOp::create(builder, loc, associate);
} else {
value =
hlfir::Entity{genRecordCPtrValueArg(builder, loc, value, eleTy)};
@@ -1626,7 +1627,7 @@ void prepareUserCallArguments(
loadedValue = builder.createConvert(
loc, fir::ReferenceType::get(argTy), loadedValue);
if (fir::isa_ref_type(loadedValue.getType()))
- loadedValue = builder.create<fir::LoadOp>(loc, loadedValue);
+ loadedValue = fir::LoadOp::create(builder, loc, loadedValue);
caller.placeInput(arg, loadedValue);
if (cleanup)
(*cleanup)();
@@ -1811,8 +1812,9 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
// In such case, the expression should not be freed after its use since
// the result is stack allocated or deallocation (for allocatable results)
// was already inserted in genCallOpAndResult.
- auto asExpr = builder.create<hlfir::AsExprOp>(
- loc, resultEntity, /*mustFree=*/builder.createBool(loc, false));
+ auto asExpr =
+ hlfir::AsExprOp::create(builder, loc, resultEntity,
+ /*mustFree=*/builder.createBool(loc, false));
return hlfir::EntityWithAttributes{asExpr.getResult()};
}
return hlfir::EntityWithAttributes{resultEntity};
@@ -1860,12 +1862,12 @@ static ExvAndCleanup genOptionalValue(fir::FirOpBuilder &builder,
"must be a numerical or logical scalar");
mlir::Value val =
hlfir::loadTrivialScalar(loc, builder, entity);
- builder.create<fir::ResultOp>(loc, val);
+ fir::ResultOp::create(builder, loc, val);
})
.genElse([&]() {
mlir::Value zero =
fir::factory::createZeroValue(builder, loc, eleType);
- builder.create<fir::ResultOp>(loc, zero);
+ fir::ResultOp::create(builder, loc, zero);
})
.getResults()[0],
std::nullopt};
@@ -1912,9 +1914,9 @@ static ExvAndCleanup genOptionalBox(fir::FirOpBuilder &builder,
// ensures it won't be.
mlir::Value box = builder.createBox(loc, newExv);
mlir::Type boxType = box.getType();
- auto absent = builder.create<fir::AbsentOp>(loc, boxType);
- auto boxOrAbsent = builder.create<mlir::arith::SelectOp>(
- loc, boxType, isPresent, box, absent);
+ auto absent = fir::AbsentOp::create(builder, loc, boxType);
+ auto boxOrAbsent = mlir::arith::SelectOp::create(builder, loc, boxType,
+ isPresent, box, absent);
return {fir::BoxValue(boxOrAbsent), cleanup};
}
@@ -2142,10 +2144,10 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
// ownership of this address cannot be taken here since it may not be a
// temp.
if (intrinsicName == "merge")
- asExpr = builder.create<hlfir::AsExprOp>(loc, resultEntity);
+ asExpr = hlfir::AsExprOp::create(builder, loc, resultEntity);
else
- asExpr = builder.create<hlfir::AsExprOp>(
- loc, resultEntity, builder.createBool(loc, mustBeFreed));
+ asExpr = hlfir::AsExprOp::create(builder, loc, resultEntity,
+ builder.createBool(loc, mustBeFreed));
resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
}
return resultEntity;
@@ -2525,7 +2527,7 @@ genIsPresentIfArgMaybeAbsent(mlir::Location loc, hlfir::Entity actual,
// May fall into the category above if the allocatable is not optional.
// Passing an optional to an optional.
- return builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), actual)
+ return fir::IsPresentOp::create(builder, loc, builder.getI1Type(), actual)
.getResult();
}
@@ -2813,9 +2815,9 @@ genProcedureRef(CallContext &callContext) {
// TYPE(*) cannot be ALLOCATABLE/POINTER (C709) so there is no
// need to cover the case of passing an ALLOCATABLE/POINTER to an
// OPTIONAL.
- isPresent =
- builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), actual)
- .getResult();
+ isPresent = fir::IsPresentOp::create(builder, loc,
+ builder.getI1Type(), actual)
+ .getResult();
}
loweredActuals.push_back(Fortran::lower::PreparedActualArgument{
hlfir::Entity{*var}, isPresent});
@@ -2931,7 +2933,7 @@ std::optional<hlfir::EntityWithAttributes> Fortran::lower::convertCallToHLFIR(
// this can be enforced whenscheduling forall/where expression evaluations.
Fortran::lower::StatementContext localStmtCtx;
mlir::Type bogusType = builder.getIndexType();
- auto exactlyOnce = builder.create<hlfir::ExactlyOnceOp>(loc, bogusType);
+ auto exactlyOnce = hlfir::ExactlyOnceOp::create(builder, loc, bogusType);
mlir::Block *block = builder.createBlock(&exactlyOnce.getBody());
builder.setInsertionPointToStart(block);
CallContext callContext(procRef, resultType, loc, converter, symMap,
@@ -2939,7 +2941,7 @@ std::optional<hlfir::EntityWithAttributes> Fortran::lower::convertCallToHLFIR(
std::optional<hlfir::EntityWithAttributes> res =
genProcedureRef(callContext);
assert(res.has_value() && "must be a function");
- auto yield = builder.create<hlfir::YieldOp>(loc, *res);
+ auto yield = hlfir::YieldOp::create(builder, loc, *res);
Fortran::lower::genCleanUpInRegionIfAny(loc, builder, yield.getCleanup(),
localStmtCtx);
builder.setInsertionPointAfter(exactlyOnce);