[flang-commits] [flang] [mlir][NFC] update `flang/Lower` create APIs (8/n) (#149687) (PR #149912)
via flang-commits
flang-commits at lists.llvm.org
Mon Jul 21 14:57:37 PDT 2025
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff HEAD~1 HEAD --extensions cpp -- flang/lib/Lower/Allocatable.cpp flang/lib/Lower/Bridge.cpp flang/lib/Lower/ConvertArrayConstructor.cpp flang/lib/Lower/ConvertCall.cpp flang/lib/Lower/ConvertConstant.cpp flang/lib/Lower/ConvertExpr.cpp flang/lib/Lower/ConvertExprToHLFIR.cpp flang/lib/Lower/ConvertProcedureDesignator.cpp flang/lib/Lower/ConvertVariable.cpp flang/lib/Lower/CustomIntrinsicCall.cpp flang/lib/Lower/HlfirIntrinsics.cpp flang/lib/Lower/HostAssociations.cpp flang/lib/Lower/IO.cpp flang/lib/Lower/OpenACC.cpp flang/lib/Lower/OpenMP/Atomic.cpp flang/lib/Lower/OpenMP/ClauseProcessor.cpp flang/lib/Lower/OpenMP/DataSharingProcessor.cpp flang/lib/Lower/OpenMP/OpenMP.cpp flang/lib/Lower/OpenMP/Utils.cpp flang/lib/Lower/Runtime.cpp flang/lib/Lower/Support/PrivateReductionUtils.cpp flang/lib/Lower/Support/ReductionProcessor.cpp flang/lib/Lower/Support/Utils.cpp flang/lib/Lower/VectorSubscripts.cpp
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/flang/lib/Lower/Allocatable.cpp b/flang/lib/Lower/Allocatable.cpp
index f6119cf8a..15cd9770b 100644
--- a/flang/lib/Lower/Allocatable.cpp
+++ b/flang/lib/Lower/Allocatable.cpp
@@ -78,8 +78,8 @@ struct ErrorManager {
statExpr && errMsgExpr
? builder.createBox(loc,
converter.genExprAddr(loc, errMsgExpr, stmtCtx))
- : fir::AbsentOp::create(builder,
- loc,
+ : fir::AbsentOp::create(
+ builder, loc,
fir::BoxType::get(mlir::NoneType::get(builder.getContext())));
sourceFile = fir::factory::locationToFilename(builder, loc);
sourceLine = fir::factory::locationToLineNo(builder, loc,
@@ -92,10 +92,10 @@ struct ErrorManager {
if (statValue) {
mlir::Value zero =
builder.createIntegerConstant(loc, statValue.getType(), 0);
- auto cmp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::eq, statValue, zero);
+ auto cmp = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::eq, statValue, zero);
auto ifOp = fir::IfOp::create(builder, loc, cmp,
- /*withElseRegion=*/false);
+ /*withElseRegion=*/false);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
}
}
@@ -597,13 +597,14 @@ private:
assert(sourceBox && "source expression should be lowered to one box");
for (int i = 0; i < sourceExpr->Rank(); ++i) {
auto dimVal = builder.createIntegerConstant(loc, idxTy, i);
- auto dimInfo = fir::BoxDimsOp::create(builder,
- loc, idxTy, idxTy, idxTy, sourceBox->getAddr(), dimVal);
+ auto dimInfo = fir::BoxDimsOp::create(builder, loc, idxTy, idxTy, idxTy,
+ sourceBox->getAddr(), dimVal);
mlir::Value lb =
fir::factory::readLowerBound(builder, loc, sourceExv, i, one);
mlir::Value extent = dimInfo.getResult(1);
- mlir::Value ub = mlir::arith::SubIOp::create(builder,
- loc, mlir::arith::AddIOp::create(builder, loc, extent, lb), one);
+ mlir::Value ub = mlir::arith::SubIOp::create(
+ builder, loc, mlir::arith::AddIOp::create(builder, loc, extent, lb),
+ one);
mlir::Value dimIndex = builder.createIntegerConstant(loc, i32Ty, i);
genRuntimeSetBounds(builder, loc, box, dimIndex, lb, ub);
}
@@ -909,8 +910,8 @@ void Fortran::lower::genDeallocateIfAllocated(
.genThen([&]() {
if (mlir::Type eleType = box.getEleTy();
mlir::isa<fir::RecordType>(eleType) && box.isPolymorphic()) {
- mlir::Value declaredTypeDesc = fir::TypeDescOp::create(builder,
- loc, mlir::TypeAttr::get(eleType));
+ mlir::Value declaredTypeDesc = fir::TypeDescOp::create(
+ builder, loc, mlir::TypeAttr::get(eleType));
genDeallocateBox(converter, box, loc, sym, declaredTypeDesc);
} else {
genDeallocateBox(converter, box, loc, sym);
@@ -1161,7 +1162,7 @@ mlir::Value Fortran::lower::getAssumedCharAllocatableOrPointerLen(
// inquire the length of absent optional, even if non deferred, so
// it's fine to use undefOp in this case.
auto isPresent = fir::IsPresentOp::create(builder, loc, builder.getI1Type(),
- fir::getBase(box));
+ fir::getBase(box));
mlir::Value len =
builder.genIfOp(loc, {idxTy}, isPresent, true)
.genThen(
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index 557fdef27..b94833d85 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -333,8 +333,9 @@ private:
if (details.numPrivatesNotOverridden() > 0)
tbpName += "."s + std::to_string(details.numPrivatesNotOverridden());
std::string bindingName = converter.mangleName(details.symbol());
- fir::DTEntryOp::create(builder,
- info.loc, mlir::StringAttr::get(builder.getContext(), tbpName),
+ fir::DTEntryOp::create(
+ builder, info.loc,
+ mlir::StringAttr::get(builder.getContext(), tbpName),
mlir::SymbolRefAttr::get(builder.getContext(), bindingName));
}
fir::FirEndOp::create(builder, info.loc);
@@ -4830,17 +4831,17 @@ private:
// Special case if the rhs is a constant.
if (matchPattern(base.getDefiningOp(), mlir::m_Constant())) {
cuf::DataTransferOp::create(builder, loc, base, lhsVal, shape,
- transferKindAttr);
+ transferKindAttr);
} else {
auto associate = hlfir::genAssociateExpr(
loc, builder, rhs, rhs.getType(), ".cuf_host_tmp");
cuf::DataTransferOp::create(builder, loc, associate.getBase(), lhsVal,
- shape, transferKindAttr);
+ shape, transferKindAttr);
hlfir::EndAssociateOp::create(builder, loc, associate);
}
} else {
cuf::DataTransferOp::create(builder, loc, rhsVal, lhsVal, shape,
- transferKindAttr);
+ transferKindAttr);
}
return;
}
@@ -4850,7 +4851,7 @@ private:
auto transferKindAttr = cuf::DataTransferKindAttr::get(
builder.getContext(), cuf::DataTransferKind::DeviceHost);
cuf::DataTransferOp::create(builder, loc, rhsVal, lhsVal, shape,
- transferKindAttr);
+ transferKindAttr);
return;
}
@@ -4860,7 +4861,7 @@ private:
auto transferKindAttr = cuf::DataTransferKindAttr::get(
builder.getContext(), cuf::DataTransferKind::DeviceDevice);
cuf::DataTransferOp::create(builder, loc, rhsVal, lhsVal, shape,
- transferKindAttr);
+ transferKindAttr);
return;
}
llvm_unreachable("Unhandled CUDA data transfer");
@@ -4906,8 +4907,9 @@ private:
addSymbol(sym,
hlfir::translateToExtendedValue(loc, builder, temp).first,
/*forced=*/true);
- cuf::DataTransferOp::create(builder,
- loc, addr, temp, /*shape=*/mlir::Value{}, transferKindAttr);
+ cuf::DataTransferOp::create(builder, loc, addr, temp,
+ /*shape=*/mlir::Value{},
+ transferKindAttr);
++nbDeviceResidentObject;
}
}
@@ -4997,8 +4999,8 @@ private:
genCUDADataTransfer(builder, loc, assign, lhs, rhs);
else
hlfir::AssignOp::create(builder, loc, rhs, lhs,
- isWholeAllocatableAssignment,
- keepLhsLengthInAllocatableAssignment);
+ isWholeAllocatableAssignment,
+ keepLhsLengthInAllocatableAssignment);
if (hasCUDAImplicitTransfer && !isInDeviceContext) {
localSymbols.popScope();
for (mlir::Value temp : implicitTemps)
diff --git a/flang/lib/Lower/ConvertArrayConstructor.cpp b/flang/lib/Lower/ConvertArrayConstructor.cpp
index a352133b7..55c4b4555 100644
--- a/flang/lib/Lower/ConvertArrayConstructor.cpp
+++ b/flang/lib/Lower/ConvertArrayConstructor.cpp
@@ -138,8 +138,8 @@ public:
if constexpr (!hasLoops)
fir::emitFatalError(loc, "array constructor lowering is inconsistent");
auto loop = fir::DoLoopOp::create(builder, loc, lower, upper, stride,
- /*unordered=*/false,
- /*finalCount=*/false);
+ /*unordered=*/false,
+ /*finalCount=*/false);
builder.setInsertionPointToStart(loop.getBody());
return loop.getInductionVar();
}
@@ -213,13 +213,13 @@ public:
assert(!elementalOp && "expected only one implied-do");
mlir::Value one =
builder.createIntegerConstant(loc, builder.getIndexType(), 1);
- elementalOp = hlfir::ElementalOp::create(builder,
- loc, exprType, shape,
- /*mold=*/nullptr, lengthParams, /*isUnordered=*/true);
+ elementalOp = hlfir::ElementalOp::create(builder, loc, exprType, shape,
+ /*mold=*/nullptr, lengthParams,
+ /*isUnordered=*/true);
builder.setInsertionPointToStart(elementalOp.getBody());
// implied-do-index = lower+((i-1)*stride)
- mlir::Value diff = mlir::arith::SubIOp::create(builder,
- loc, elementalOp.getIndices()[0], one);
+ mlir::Value diff = mlir::arith::SubIOp::create(
+ builder, loc, elementalOp.getIndices()[0], one);
mlir::Value mul = mlir::arith::MulIOp::create(builder, loc, diff, stride);
mlir::Value add = mlir::arith::AddIOp::create(builder, loc, lower, mul);
return add;
@@ -315,8 +315,8 @@ public:
mlir::Value tempStorage = builder.createHeapTemporary(
loc, declaredType, tempName, extents, lengths);
mlir::Value shape = builder.genShape(loc, extents);
- declare = hlfir::DeclareOp::create(builder,
- loc, tempStorage, tempName, shape, lengths,
+ declare = hlfir::DeclareOp::create(
+ builder, loc, tempStorage, tempName, shape, lengths,
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
initialBoxValue =
builder.createBox(loc, boxType, declare->getOriginalBase(), shape,
@@ -390,8 +390,8 @@ public:
mlir::Value lower, mlir::Value upper,
mlir::Value stride) {
auto loop = fir::DoLoopOp::create(builder, loc, lower, upper, stride,
- /*unordered=*/false,
- /*finalCount=*/false);
+ /*unordered=*/false,
+ /*finalCount=*/false);
builder.setInsertionPointToStart(loop.getBody());
return loop.getInductionVar();
}
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index 4c7ec7a10..8c3648bcb 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -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 = hlfir::DesignateOp::create(builder,
- 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);
@@ -230,7 +230,7 @@ static mlir::Value remapActualToDummyDescriptor(
mold = explicitArgument;
mlir::Value remapped =
fir::EmboxOp::create(builder, loc, dummyBoxType, baseAddr, shape,
- /*slice=*/mlir::Value{}, lengths, mold);
+ /*slice=*/mlir::Value{}, lengths, mold);
if (mapSymbols)
symMap.popScope();
return remapped;
@@ -381,8 +381,8 @@ Fortran::lower::genCallOpAndResult(
if (isExprCall) {
mlir::Type exprType = hlfir::getExprType(type);
- evaluateInMemory = hlfir::EvaluateInMemoryOp::create(builder,
- 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);
@@ -499,8 +499,8 @@ Fortran::lower::genCallOpAndResult(
auto funcTy = mlir::FunctionType::get(context, {}, {});
auto boxProcTy = builder.getBoxProcType(funcTy);
if (mlir::Value host = argumentHostAssocs(converter, fst)) {
- cast = fir::EmboxProcOp::create(builder,
- loc, boxProcTy, llvm::ArrayRef<mlir::Value>{fst, host});
+ cast = fir::EmboxProcOp::create(builder, loc, boxProcTy,
+ llvm::ArrayRef<mlir::Value>{fst, host});
} else {
cast = fir::EmboxProcOp::create(builder, loc, boxProcTy, fst);
}
@@ -613,10 +613,10 @@ Fortran::lower::genCallOpAndResult(
stream = fir::getBase(converter.genExprAddr(
caller.getCallDescription().chevrons()[3], stmtCtx));
- 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);
+ 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 = fir::DispatchOp::create(builder,
- 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);
@@ -657,8 +657,8 @@ Fortran::lower::genCallOpAndResult(
if (fir::isa_ref_type(passObject.getType()))
passObject = fir::LoadOp::create(builder, loc, passObject);
- dispatch = fir::DispatchOp::create(builder,
- loc, funcType.getResults(), builder.getStringAttr(procName),
+ 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 = fir::CallOp::create(builder,
- 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();
@@ -692,8 +692,8 @@ Fortran::lower::genCallOpAndResult(
if (caller.mustSaveResult()) {
assert(allocatedResult.has_value());
fir::SaveResultOp::create(builder, loc, callResult,
- fir::getBase(*allocatedResult),
- arrayResultShape, resultLengths);
+ fir::getBase(*allocatedResult), arrayResultShape,
+ resultLengths);
}
if (evaluateInMemory) {
@@ -952,8 +952,8 @@ extendedValueToHlfirEntity(mlir::Location loc, fir::FirOpBuilder &builder,
// little incentive to increase the compiler complexity.
hlfir::Entity storage{builder.createTemporary(loc, charTy)};
fir::StoreOp::create(builder, loc, firBase, storage);
- auto asExpr = hlfir::AsExprOp::create(builder,
- loc, storage, /*mustFree=*/builder.createBool(loc, false));
+ 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,
@@ -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 = hlfir::CopyInOp::create(builder,
- 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{fir::ReboxAssumedRankOp::create(builder,
- 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{fir::ReboxOp::create(builder, loc, boxType, var,
- /*shape=*/mlir::Value{},
- /*slice=*/mlir::Value{})};
+ /*shape=*/mlir::Value{},
+ /*slice=*/mlir::Value{})};
};
// Step 2: prepare the storage for the dummy arguments, ensuring that it
@@ -1441,14 +1442,14 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
auto lbModifier = needsZeroLowerBounds
? fir::LowerBoundModifierAttribute::SetToZeroes
: fir::LowerBoundModifierAttribute::SetToOnes;
- entity = hlfir::Entity{fir::ReboxAssumedRankOp::create(builder,
- 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{fir::ReboxOp::create(builder,
- loc, dummyTypeWithActualRank, entity, /*shape=*/shift,
+ entity = hlfir::Entity{fir::ReboxOp::create(
+ builder, loc, dummyTypeWithActualRank, entity, /*shape=*/shift,
/*slice=*/mlir::Value{})};
}
}
@@ -1502,7 +1503,7 @@ static PreparedDummyArgument prepareUserCallActualArgument(
// and types of the if results will depend on how the argument
// is prepared, and forecasting that here would be brittle.
auto badIfOp = fir::IfOp::create(builder, loc, dummyType, isPresent,
- /*withElseRegion=*/false);
+ /*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 = fir::IfOp::create(builder, 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.
@@ -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 = hlfir::AsExprOp::create(builder,
- 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};
@@ -1913,8 +1915,8 @@ static ExvAndCleanup genOptionalBox(fir::FirOpBuilder &builder,
mlir::Value box = builder.createBox(loc, newExv);
mlir::Type boxType = box.getType();
auto absent = fir::AbsentOp::create(builder, loc, boxType);
- auto boxOrAbsent = mlir::arith::SelectOp::create(builder,
- loc, boxType, isPresent, box, absent);
+ auto boxOrAbsent = mlir::arith::SelectOp::create(builder, loc, boxType,
+ isPresent, box, absent);
return {fir::BoxValue(boxOrAbsent), cleanup};
}
@@ -2144,8 +2146,8 @@ genIntrinsicRefCore(Fortran::lower::PreparedActualArguments &loweredActuals,
if (intrinsicName == "merge")
asExpr = hlfir::AsExprOp::create(builder, loc, resultEntity);
else
- asExpr = hlfir::AsExprOp::create(builder,
- loc, resultEntity, builder.createBool(loc, mustBeFreed));
+ asExpr = hlfir::AsExprOp::create(builder, loc, resultEntity,
+ builder.createBool(loc, mustBeFreed));
resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
}
return resultEntity;
@@ -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 =
- fir::IsPresentOp::create(builder, 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});
diff --git a/flang/lib/Lower/ConvertConstant.cpp b/flang/lib/Lower/ConvertConstant.cpp
index cd4be3707..768a237c9 100644
--- a/flang/lib/Lower/ConvertConstant.cpp
+++ b/flang/lib/Lower/ConvertConstant.cpp
@@ -237,8 +237,8 @@ static mlir::Value genScalarLit(
? value.UnsignedDecimal()
: value.SignedDecimal(),
10);
- return mlir::arith::ConstantOp::create(builder,
- loc, ty, mlir::IntegerAttr::get(ty, bigInt));
+ return mlir::arith::ConstantOp::create(
+ builder, loc, ty, mlir::IntegerAttr::get(ty, bigInt));
}
return builder.createIntegerConstant(loc, ty, value.ToInt64());
} else if constexpr (TC == Fortran::common::TypeCategory::Logical) {
@@ -302,8 +302,9 @@ createStringLitOp(fir::FirOpBuilder &builder, mlir::Location loc,
auto sizeTag = mlir::StringAttr::get(context, fir::StringLitOp::size());
mlir::NamedAttribute sizeAttr(sizeTag, builder.getI64IntegerAttr(len));
llvm::SmallVector<mlir::NamedAttribute> attrs = {dataAttr, sizeAttr};
- return fir::StringLitOp::create(builder,
- loc, llvm::ArrayRef<mlir::Type>{type}, mlir::ValueRange{}, attrs);
+ return fir::StringLitOp::create(builder, loc,
+ llvm::ArrayRef<mlir::Type>{type},
+ mlir::ValueRange{}, attrs);
}
}
@@ -344,7 +345,7 @@ genScalarLit(fir::FirOpBuilder &builder, mlir::Location loc,
},
builder.createLinkOnceLinkage());
return fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
}
// Helper to generate StructureConstructor component values.
@@ -364,9 +365,9 @@ static mlir::Value genStructureComponentInit(
auto fieldTy = fir::FieldType::get(recTy.getContext());
assert(componentTy && "failed to retrieve component");
// FIXME: type parameters must come from the derived-type-spec
- auto field = fir::FieldIndexOp::create(builder,
- loc, fieldTy, name, recTy,
- /*typeParams=*/mlir::ValueRange{} /*TODO*/);
+ auto field =
+ fir::FieldIndexOp::create(builder, loc, fieldTy, name, recTy,
+ /*typeParams=*/mlir::ValueRange{} /*TODO*/);
if (Fortran::semantics::IsAllocatable(sym)) {
if (!Fortran::evaluate::IsNullPointerOrAllocatable(&expr)) {
@@ -378,8 +379,8 @@ static mlir::Value genStructureComponentInit(
fir::factory::createUnallocatedBox(builder, loc, componentTy, {})};
componentValue = builder.createConvert(loc, componentTy, componentValue);
- return fir::InsertValueOp::create(builder,
- loc, recTy, res, componentValue,
+ return fir::InsertValueOp::create(
+ builder, loc, recTy, res, componentValue,
builder.getArrayAttr(field.getAttributes()));
}
}
@@ -400,9 +401,9 @@ static mlir::Value genStructureComponentInit(
} else
initialTarget = Fortran::lower::genInitialDataTarget(converter, loc,
componentTy, expr);
- res = fir::InsertValueOp::create(builder,
- loc, recTy, res, initialTarget,
- builder.getArrayAttr(field.getAttributes()));
+ res =
+ fir::InsertValueOp::create(builder, loc, recTy, res, initialTarget,
+ builder.getArrayAttr(field.getAttributes()));
return res;
}
@@ -435,24 +436,25 @@ static mlir::Value genStructureComponentInit(
auto cPtrRecTy = mlir::cast<fir::RecordType>(componentTy);
llvm::StringRef addrFieldName = Fortran::lower::builtin::cptrFieldName;
mlir::Type addrFieldTy = cPtrRecTy.getType(addrFieldName);
- auto addrField = fir::FieldIndexOp::create(builder,
- loc, fieldTy, addrFieldName, componentTy,
+ auto addrField = fir::FieldIndexOp::create(
+ builder, loc, fieldTy, addrFieldName, componentTy,
/*typeParams=*/mlir::ValueRange{});
mlir::Value castAddr = builder.createConvert(loc, addrFieldTy, addr);
auto undef = fir::UndefOp::create(builder, loc, componentTy);
- addr = fir::InsertValueOp::create(builder,
- loc, componentTy, undef, castAddr,
+ addr = fir::InsertValueOp::create(
+ builder, loc, componentTy, undef, castAddr,
builder.getArrayAttr(addrField.getAttributes()));
- res = fir::InsertValueOp::create(builder,
- loc, recTy, res, addr, builder.getArrayAttr(field.getAttributes()));
+ res =
+ fir::InsertValueOp::create(builder, loc, recTy, res, addr,
+ builder.getArrayAttr(field.getAttributes()));
return res;
}
mlir::Value val = fir::getBase(genConstantValue(converter, loc, expr));
assert(!fir::isa_ref_type(val.getType()) && "expecting a constant value");
mlir::Value castVal = builder.createConvert(loc, componentTy, val);
- res = fir::InsertValueOp::create(builder,
- loc, recTy, res, castVal, builder.getArrayAttr(field.getAttributes()));
+ res = fir::InsertValueOp::create(builder, loc, recTy, res, castVal,
+ builder.getArrayAttr(field.getAttributes()));
return res;
}
@@ -497,11 +499,11 @@ static mlir::Value genInlinedStructureCtorLitImpl(
for (mlir::Type parentType : llvm::reverse(parentTypes)) {
auto undef = fir::UndefOp::create(builder, loc, parentType);
fir::RecordType parentRecTy = mlir::cast<fir::RecordType>(parentType);
- auto field = fir::FieldIndexOp::create(builder,
- loc, fieldTy, parentRecTy.getTypeList()[0].first, parentType,
+ auto field = fir::FieldIndexOp::create(
+ builder, loc, fieldTy, parentRecTy.getTypeList()[0].first, parentType,
/*typeParams=*/mlir::ValueRange{} /*TODO*/);
- res = fir::InsertValueOp::create(builder,
- loc, parentRecTy, undef, res,
+ res = fir::InsertValueOp::create(
+ builder, loc, parentRecTy, undef, res,
builder.getArrayAttr(field.getAttributes()));
}
};
@@ -555,7 +557,7 @@ static mlir::Value genScalarLit(
builder.createInternalLinkage());
}
return fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
}
/// Create an evaluate::Constant<T> array to a fir.array<> value
@@ -584,8 +586,9 @@ genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
mlir::Value elementVal =
genScalarLit<T::kind>(builder, loc, con.At(subscripts), con.LEN(),
/*outlineInReadOnlyMemory=*/false);
- array = fir::InsertValueOp::create(builder,
- loc, arrayTy, array, elementVal, builder.getArrayAttr(createIdx()));
+ array =
+ fir::InsertValueOp::create(builder, loc, arrayTy, array, elementVal,
+ builder.getArrayAttr(createIdx()));
} while (con.IncrementSubscripts(subscripts));
} else if constexpr (T::category == Fortran::common::TypeCategory::Derived) {
do {
@@ -594,8 +597,9 @@ genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
mlir::Value elementVal =
genScalarLit(converter, loc, con.At(subscripts), eleTy,
/*outlineInReadOnlyMemory=*/false);
- array = fir::InsertValueOp::create(builder,
- loc, arrayTy, array, elementVal, builder.getArrayAttr(createIdx()));
+ array =
+ fir::InsertValueOp::create(builder, loc, arrayTy, array, elementVal,
+ builder.getArrayAttr(createIdx()));
} while (con.IncrementSubscripts(subscripts));
} else {
llvm::SmallVector<mlir::Attribute> rangeStartIdx;
@@ -611,9 +615,9 @@ genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
bool nextIsSame = con.IncrementSubscripts(nextSubscripts) &&
con.At(subscripts) == con.At(nextSubscripts);
if (!rangeSize && !nextIsSame) { // single (non-range) value
- array = fir::InsertValueOp::create(builder,
- loc, arrayTy, array, getElementVal(),
- builder.getArrayAttr(createIdx()));
+ array = fir::InsertValueOp::create(builder, loc, arrayTy, array,
+ getElementVal(),
+ builder.getArrayAttr(createIdx()));
} else if (!rangeSize) { // start a range
rangeStartIdx = createIdx();
rangeSize = 1;
@@ -629,8 +633,8 @@ genInlinedArrayLit(Fortran::lower::AbstractConverter &converter,
rangeBounds.push_back(
mlir::cast<mlir::IntegerAttr>(idx[i]).getValue().getSExtValue());
}
- array = fir::InsertOnRangeOp::create(builder,
- loc, arrayTy, array, getElementVal(),
+ array = fir::InsertOnRangeOp::create(
+ builder, loc, arrayTy, array, getElementVal(),
builder.getIndexVectorAttr(rangeBounds));
rangeSize = 0;
}
@@ -684,7 +688,7 @@ genOutlineArrayLit(Fortran::lower::AbstractConverter &converter,
builder.createInternalLinkage());
}
return fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
}
/// Convert an evaluate::Constant<T> array into an fir::ExtendedValue.
diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp
index a2fbec651..3578f941e 100644
--- a/flang/lib/Lower/ConvertExpr.cpp
+++ b/flang/lib/Lower/ConvertExpr.cpp
@@ -268,7 +268,7 @@ static mlir::Value genActualIsPresentTest(fir::FirOpBuilder &builder,
// when passed to CMPLX as per 15.5.2.12 point 3 (7) and (8)). It is
// therefore possible to catch them in the `then` case above.
return fir::IsPresentOp::create(builder, loc, builder.getI1Type(),
- fir::getBase(actual));
+ fir::getBase(actual));
}
/// Convert the array_load, `load`, to an extended value. If `path` is not
@@ -346,7 +346,7 @@ arrayLoadExtValue(fir::FirOpBuilder &builder, mlir::Location loc,
if (shapeVal) {
// shapeVal is a ShiftOp and load.memref() is a boxed value.
newBase = fir::ReboxOp::create(builder, loc, oldBox.getType(), oldBox,
- shapeVal, /*slice=*/mlir::Value{});
+ shapeVal, /*slice=*/mlir::Value{});
origins = fir::factory::getOrigins(shapeVal);
}
return fir::substBase(arrayToExtendedValue(extents, origins), newBase);
@@ -522,8 +522,8 @@ static fir::ExtendedValue genOptionalBox(fir::FirOpBuilder &builder,
mlir::Value box = builder.createBox(loc, newExv);
mlir::Type boxType = box.getType();
auto absent = fir::AbsentOp::create(builder, loc, boxType);
- auto boxOrAbsent = mlir::arith::SelectOp::create(builder,
- loc, boxType, isPresent, box, absent);
+ auto boxOrAbsent = mlir::arith::SelectOp::create(builder, loc, boxType,
+ isPresent, box, absent);
return fir::BoxValue(boxOrAbsent);
}
@@ -573,8 +573,8 @@ createBoxProcCharTuple(Fortran::lower::AbstractConverter &converter,
auto boxProc = [&]() -> mlir::Value {
if (auto host = Fortran::lower::argumentHostAssocs(converter, funcAddr))
- return fir::EmboxProcOp::create(builder,
- loc, boxTy, llvm::ArrayRef<mlir::Value>{funcAddr, host});
+ return fir::EmboxProcOp::create(
+ builder, loc, boxTy, llvm::ArrayRef<mlir::Value>{funcAddr, host});
return fir::EmboxProcOp::create(builder, loc, boxTy, funcAddr);
}();
return fir::factory::createCharacterProcedureTuple(builder, loc, argTy,
@@ -970,12 +970,12 @@ public:
std::string name = converter.getRecordTypeFieldName(sym);
// FIXME: type parameters must come from the derived-type-spec
- mlir::Value field = fir::FieldIndexOp::create(builder,
- loc, fieldTy, name, ty,
- /*typeParams=*/mlir::ValueRange{} /*TODO*/);
+ mlir::Value field =
+ fir::FieldIndexOp::create(builder, loc, fieldTy, name, ty,
+ /*typeParams=*/mlir::ValueRange{} /*TODO*/);
mlir::Type coorTy = builder.getRefType(recTy.getType(name));
auto coor = fir::CoordinateOp::create(builder, loc, coorTy,
- fir::getBase(res), field);
+ fir::getBase(res), field);
ExtValue to = fir::factory::componentToExtendedValue(builder, loc, coor);
to.match(
[&](const fir::UnboxedValue &toPtr) {
@@ -1384,8 +1384,9 @@ public:
mlir::Value offset = builder.createIntegerConstant(
loc, idxTy,
x.part() == Fortran::evaluate::ComplexPart::Part::RE ? 0 : 1);
- mlir::Value result = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(eleTy), base, mlir::ValueRange{offset});
+ mlir::Value result =
+ fir::CoordinateOp::create(builder, loc, builder.getRefType(eleTy), base,
+ mlir::ValueRange{offset});
return {result};
}
ExtValue genval(const Fortran::evaluate::ComplexPart &x) {
@@ -1500,8 +1501,8 @@ public:
auto recTy = mlir::cast<fir::RecordType>(ty);
const Fortran::semantics::Symbol &sym = getLastSym(*field);
std::string name = converter.getRecordTypeFieldName(sym);
- coorArgs.push_back(fir::FieldIndexOp::create(builder,
- loc, fldTy, name, recTy, fir::getTypeParams(obj)));
+ coorArgs.push_back(fir::FieldIndexOp::create(
+ builder, loc, fldTy, name, recTy, fir::getTypeParams(obj)));
ty = recTy.getType(name);
}
// If parent component is referred then it has no coordinate argument.
@@ -1511,7 +1512,7 @@ public:
return fir::factory::componentToExtendedValue(
builder, loc,
fir::CoordinateOp::create(builder, loc, ty, fir::getBase(obj),
- coorArgs));
+ coorArgs));
}
ExtValue gen(const Fortran::evaluate::Component &cmpt) {
@@ -1672,8 +1673,8 @@ public:
base = builder.createConvert(loc, seqRefTy, base);
}
}
- auto coor = fir::CoordinateOp::create(builder,
- loc, refTy, base, llvm::ArrayRef<mlir::Value>{total});
+ auto coor = fir::CoordinateOp::create(builder, loc, refTy, base,
+ llvm::ArrayRef<mlir::Value>{total});
// Convert to expected, original type after address arithmetic.
return builder.createConvert(loc, origRefTy, coor);
};
@@ -1725,9 +1726,9 @@ public:
builder.createConvert(loc, idxTy, fir::getBase(subVal)));
}
mlir::Value shape = builder.createShape(loc, exv);
- mlir::Value elementAddr = fir::ArrayCoorOp::create(builder,
- loc, refTy, addr, shape, /*slice=*/mlir::Value{}, arrayCoorArgs,
- fir::getTypeParams(exv));
+ mlir::Value elementAddr = fir::ArrayCoorOp::create(
+ builder, loc, refTy, addr, shape, /*slice=*/mlir::Value{},
+ arrayCoorArgs, fir::getTypeParams(exv));
return fir::factory::arrayElementToExtendedValue(builder, loc, exv,
elementAddr);
}
@@ -1827,7 +1828,7 @@ public:
auto boxProcTy =
builder.getBoxProcType(mlir::cast<mlir::FunctionType>(exvTy));
return fir::EmboxProcOp::create(builder, loc, boxProcTy,
- fir::getBase(exv));
+ fir::getBase(exv));
}
mlir::Value box = builder.createBox(loc, exv, exv.isPolymorphic());
if (Fortran::lower::isParentComponent(expr)) {
@@ -2073,8 +2074,8 @@ public:
TODO(loc, "creating temporary for derived type with length parameters");
}
- mlir::Value temp = fir::AllocMemOp::create(builder,
- loc, type, tempName, allocMemTypeParams, extents);
+ mlir::Value temp = fir::AllocMemOp::create(builder, loc, type, tempName,
+ allocMemTypeParams, extents);
if (mlir::isa<fir::CharacterType>(fir::unwrapSequenceType(type)))
return fir::CharArrayBoxValue{temp, charLen, extents};
return fir::ArrayBoxValue{temp, extents};
@@ -2258,13 +2259,14 @@ public:
if (isActualArgBox) {
mlir::Value zero =
builder.createIntegerConstant(loc, builder.getI1Type(), 0);
- mlir::Value notContiguous = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::eq, isContiguousResult, zero);
+ mlir::Value notContiguous = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::eq, isContiguousResult,
+ zero);
if (!restrictCopyAtRuntime) {
restrictCopyAtRuntime = notContiguous;
} else {
- mlir::Value cond = mlir::arith::AndIOp::create(builder,
- loc, *restrictCopyAtRuntime, notContiguous);
+ mlir::Value cond = mlir::arith::AndIOp::create(
+ builder, loc, *restrictCopyAtRuntime, notContiguous);
restrictCopyAtRuntime = cond;
}
}
@@ -2313,7 +2315,7 @@ public:
.genElse([&]() {
ExtValue temp = doCopyIn();
fir::ResultOp::create(builder, loc,
- fir::getBase(temp));
+ fir::getBase(temp));
})
.getResults()[0];
fir::ResultOp::create(builder, loc, addr1);
@@ -2377,8 +2379,8 @@ public:
mlir::cast<fir::BaseBoxType>(srcBox.getType())
.getBoxTypeWithNewAttr(fir::BaseBoxType::Attribute::Allocatable);
srcBox = fir::ReboxOp::create(builder, loc, allocBoxTy, srcBox,
- /*shift=*/mlir::Value{},
- /*slice=*/mlir::Value{});
+ /*shift=*/mlir::Value{},
+ /*slice=*/mlir::Value{});
mlir::Value srcBoxRef = builder.createTemporary(loc, srcBox.getType());
fir::StoreOp::create(builder, loc, srcBox, srcBoxRef);
// Create descriptor pointer to variable descriptor if copy out is needed,
@@ -2436,8 +2438,8 @@ public:
// fir.box is absent.
ExtValue actualArg = gen(expr);
mlir::Value actualArgBase = fir::getBase(actualArg);
- mlir::Value isPresent = fir::IsPresentOp::create(builder,
- loc, builder.getI1Type(), actualArgBase);
+ mlir::Value isPresent = fir::IsPresentOp::create(
+ builder, loc, builder.getI1Type(), actualArgBase);
if (!mlir::isa<fir::BoxType>(actualArgBase.getType()))
return {actualArg, isPresent};
ExtValue safeToReadBox =
@@ -2706,9 +2708,10 @@ public:
mlir::cast<fir::BoxCharType>(funcTy.getResult(0));
mlir::Value ref = builder.createConvertWithVolatileCast(
loc, builder.getRefType(boxTy.getEleTy()), x.getAddr());
- auto len = fir::UndefOp::create(builder,
- loc, builder.getCharacterLengthType());
- return fir::EmboxCharOp::create(builder, loc, boxTy, ref, len);
+ auto len = fir::UndefOp::create(
+ builder, loc, builder.getCharacterLengthType());
+ return fir::EmboxCharOp::create(builder, loc, boxTy, ref,
+ len);
}
return helper.createEmbox(x);
},
@@ -2759,9 +2762,9 @@ public:
if (isPresentValue) {
mlir::Value convertedBox = builder.createConvert(loc, argTy, box);
auto absent = fir::AbsentOp::create(builder, loc, argTy);
- caller.placeInput(arg,
- mlir::arith::SelectOp::create(builder,
- loc, *isPresentValue, convertedBox, absent));
+ caller.placeInput(
+ arg, mlir::arith::SelectOp::create(
+ builder, loc, *isPresentValue, convertedBox, absent));
} else {
caller.placeInput(arg, builder.createBox(loc, argAddr));
}
@@ -2802,13 +2805,14 @@ public:
} else if (mlir::isa<fir::BoxType>(box.getType()) &&
fir::isPolymorphicType(argTy)) {
box = fir::ReboxOp::create(builder, loc, argTy, box, mlir::Value{},
- /*slice=*/mlir::Value{});
+ /*slice=*/mlir::Value{});
}
// Need the box types to be exactly similar for the selectOp.
mlir::Value convertedBox = builder.createConvert(loc, argTy, box);
- caller.placeInput(arg, mlir::arith::SelectOp::create(builder,
- loc, isAllocated, convertedBox, absent));
+ caller.placeInput(
+ arg, mlir::arith::SelectOp::create(builder, loc, isAllocated,
+ convertedBox, absent));
} else {
auto dynamicType = expr->GetType();
mlir::Value box;
@@ -2833,8 +2837,8 @@ public:
fir::ResultOp::create(builder, loc, boxed);
})
.genElse([&]() {
- auto absent =
- fir::AbsentOp::create(builder, loc, argTy).getResult();
+ auto absent = fir::AbsentOp::create(builder, loc, argTy)
+ .getResult();
fir::ResultOp::create(builder, loc, absent);
})
.getResults()[0];
@@ -2878,8 +2882,8 @@ public:
.getResults()[0];
} else {
box = fir::ReboxOp::create(builder, loc, actualTy, box,
- mlir::Value{},
- /*slice=*/mlir::Value{});
+ mlir::Value{},
+ /*slice=*/mlir::Value{});
}
} else if (Fortran::lower::isParentComponent(*expr)) {
fir::ExtendedValue newExv =
@@ -3188,16 +3192,16 @@ createDerivedArrayAmend(mlir::Location loc, fir::ArrayLoadOp destLoad,
} else {
auto boxTy = fir::BoxType::get(eleTy);
auto toBox = fir::EmboxOp::create(builder, loc, boxTy, destAcc.getResult(),
- mlir::Value{}, mlir::Value{},
- destLoad.getTypeparams());
- auto fromBox = fir::EmboxOp::create(builder,
- loc, boxTy, fir::getBase(elementExv), mlir::Value{}, mlir::Value{},
- destLoad.getTypeparams());
+ mlir::Value{}, mlir::Value{},
+ destLoad.getTypeparams());
+ auto fromBox = fir::EmboxOp::create(
+ builder, loc, boxTy, fir::getBase(elementExv), mlir::Value{},
+ mlir::Value{}, destLoad.getTypeparams());
fir::factory::genRecordAssignment(builder, loc, fir::BoxValue(toBox),
fir::BoxValue(fromBox));
}
return fir::ArrayAmendOp::create(builder, loc, innerArg.getType(), innerArg,
- destAcc);
+ destAcc);
}
inline static fir::ArrayAmendOp
@@ -3317,8 +3321,8 @@ public:
explicitSpace->finalizeContext();
fir::ResultOp::create(builder, loc, fir::getBase(exv));
} else {
- fir::ArrayMergeStoreOp::create(builder,
- loc, destination, fir::getBase(exv), destination.getMemref(),
+ fir::ArrayMergeStoreOp::create(
+ builder, loc, destination, fir::getBase(exv), destination.getMemref(),
destination.getSlice(), destination.getTypeparams());
}
}
@@ -3432,8 +3436,8 @@ public:
assert(destination && "destination must have been set");
ExtValue exv = lowerArrayExpression(rhsCC, destination.getType());
if (!explicitSpaceIsActive())
- fir::ArrayMergeStoreOp::create(builder,
- loc, destination, fir::getBase(exv), destination.getMemref(),
+ fir::ArrayMergeStoreOp::create(
+ builder, loc, destination, fir::getBase(exv), destination.getMemref(),
destination.getSlice(), destination.getTypeparams());
// destShape may originally be null, if rhs did not define a shape.
// In this case the destShape is computed from lhs, and we may have
@@ -3548,8 +3552,8 @@ public:
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::Location loc = converter.getCurrentLocation();
fir::ArrayMergeStoreOp::create(builder, loc, dest, fir::getBase(loopRes),
- tempRes, dest.getSlice(),
- dest.getTypeparams());
+ tempRes, dest.getSlice(),
+ dest.getTypeparams());
auto arrTy = mlir::cast<fir::SequenceType>(
fir::dyn_cast_ptrEleTy(tempRes.getType()));
@@ -3595,8 +3599,8 @@ public:
// as there isn't any necessity for it.
ccLoadDest = [=](llvm::ArrayRef<mlir::Value> shape) -> fir::ArrayLoadOp {
mlir::Value one = builder.createIntegerConstant(loc, i32Ty, 1);
- auto var = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(hdrTy.getType(1)), header, one);
+ auto var = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(hdrTy.getType(1)), header, one);
auto load = fir::LoadOp::create(builder, loc, var);
mlir::Type eleTy =
fir::unwrapSequenceType(fir::unwrapRefType(load.getType()));
@@ -3605,15 +3609,15 @@ public:
builder.createConvert(loc, fir::HeapType::get(seqTy), load);
mlir::Value shapeOp = builder.genShape(loc, shape);
return fir::ArrayLoadOp::create(builder, loc, seqTy, castTo, shapeOp,
- /*slice=*/mlir::Value{},
- mlir::ValueRange{});
+ /*slice=*/mlir::Value{},
+ mlir::ValueRange{});
};
// Custom lowering of the element store to deal with the extra indirection
// to the lazy allocated buffer.
ccStoreToDest = [=](IterSpace iters) {
mlir::Value one = builder.createIntegerConstant(loc, i32Ty, 1);
- auto var = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(hdrTy.getType(1)), header, one);
+ auto var = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(hdrTy.getType(1)), header, one);
auto load = fir::LoadOp::create(builder, loc, var);
mlir::Type eleTy =
fir::unwrapSequenceType(fir::unwrapRefType(load.getType()));
@@ -3623,8 +3627,8 @@ public:
mlir::Value shape = builder.genShape(loc, genIterationShape());
llvm::SmallVector<mlir::Value> indices = fir::factory::originateIndices(
loc, builder, castTo.getType(), shape, iters.iterVec());
- auto eleAddr = fir::ArrayCoorOp::create(builder,
- loc, builder.getRefType(eleTy), castTo, shape,
+ auto eleAddr = fir::ArrayCoorOp::create(
+ builder, loc, builder.getRefType(eleTy), castTo, shape,
/*slice=*/mlir::Value{}, indices, destination.getTypeparams());
mlir::Value eleVal =
builder.createConvert(loc, eleTy, iters.getElement());
@@ -3686,8 +3690,8 @@ public:
explicitSpace->finalizeContext();
fir::ResultOp::create(builder, loc, fir::getBase(exv));
} else {
- fir::ArrayMergeStoreOp::create(builder,
- loc, destination, fir::getBase(exv), destination.getMemref(),
+ fir::ArrayMergeStoreOp::create(
+ builder, loc, destination, fir::getBase(exv), destination.getMemref(),
destination.getSlice(), destination.getTypeparams());
}
}
@@ -4009,7 +4013,7 @@ private:
auto shiftTy = fir::ShiftType::get(eleTy.getContext(), lbs.size());
mlir::Value shiftOp = fir::ShiftOp::create(builder, loc, shiftTy, lbs);
val = fir::ReboxOp::create(builder, loc, eleTy, val, shiftOp,
- mlir::Value{});
+ mlir::Value{});
}
} else if (isBoundsRemap()) {
assert(lbounds.has_value());
@@ -4022,7 +4026,7 @@ private:
mlir::Value shapeShift =
fir::ShapeShiftOp::create(builder, loc, shapeTy, shapeShiftArgs);
val = fir::ReboxOp::create(builder, loc, eleTy, val, shapeShift,
- mlir::Value{});
+ mlir::Value{});
}
}
return val;
@@ -4045,8 +4049,8 @@ private:
// memory into the destination array.
mlir::Type resRefTy = builder.getRefType(eleTy);
// Get a reference to the array element to be amended.
- auto arrayOp = fir::ArrayAccessOp::create(builder,
- loc, resRefTy, innerArg, iterSpace.iterVec(),
+ auto arrayOp = fir::ArrayAccessOp::create(
+ builder, loc, resRefTy, innerArg, iterSpace.iterVec(),
fir::factory::getTypeParams(loc, builder, destination));
if (auto charTy = mlir::dyn_cast<fir::CharacterType>(eleTy)) {
llvm::SmallVector<mlir::Value> substringBounds;
@@ -4067,9 +4071,9 @@ private:
}
// By value semantics. The element is being assigned by value.
auto ele = convertElementForUpdate(loc, eleTy, fir::getBase(exv));
- auto update = fir::ArrayUpdateOp::create(builder,
- loc, arrTy, innerArg, ele, iterSpace.iterVec(),
- destination.getTypeparams());
+ auto update = fir::ArrayUpdateOp::create(builder, loc, arrTy, innerArg,
+ ele, iterSpace.iterVec(),
+ destination.getTypeparams());
return abstractArrayExtValue(update);
};
}
@@ -4247,9 +4251,10 @@ private:
// Compute the dynamic position into the header.
llvm::SmallVector<mlir::Value> offsets;
for (auto doLoop : loopStack[i]) {
- auto m = mlir::arith::SubIOp::create(builder,
- loc, doLoop.getInductionVar(), doLoop.getLowerBound());
- auto n = mlir::arith::DivSIOp::create(builder, loc, m, doLoop.getStep());
+ auto m = mlir::arith::SubIOp::create(
+ builder, loc, doLoop.getInductionVar(), doLoop.getLowerBound());
+ auto n =
+ mlir::arith::DivSIOp::create(builder, loc, m, doLoop.getStep());
mlir::Value one = builder.createIntegerConstant(loc, n.getType(), 1);
offsets.push_back(mlir::arith::AddIOp::create(builder, loc, n, one));
}
@@ -4262,15 +4267,17 @@ private:
auto ldHdr = fir::LoadOp::create(builder, loc, hdOff);
mlir::Value hdArr = builder.createConvert(loc, toRefTy, ldHdr);
auto shapeOp = builder.genShape(loc, extents);
- header = fir::ArrayCoorOp::create(builder,
- loc, builder.getRefType(raggedTy), hdArr, shapeOp,
+ header = fir::ArrayCoorOp::create(
+ builder, loc, builder.getRefType(raggedTy), hdArr, shapeOp,
/*slice=*/mlir::Value{}, offsets,
/*typeparams=*/mlir::ValueRange{});
- auto hdrVar = fir::CoordinateOp::create(builder, loc, coorTy, header, uno);
+ auto hdrVar =
+ fir::CoordinateOp::create(builder, loc, coorTy, header, uno);
auto inVar = fir::LoadOp::create(builder, loc, hdrVar);
mlir::Value two = builder.createIntegerConstant(loc, i32Ty, 2);
mlir::Type coorTy2 = builder.getRefType(raggedTy.getType(2));
- auto hdrSh = fir::CoordinateOp::create(builder, loc, coorTy2, header, two);
+ auto hdrSh =
+ fir::CoordinateOp::create(builder, loc, coorTy2, header, two);
auto shapePtr = fir::LoadOp::create(builder, loc, hdrSh);
// Replace the binding.
implicitSpace->rebind(expr, genMaskAccess(inVar, shapePtr));
@@ -4327,8 +4334,9 @@ private:
fir::factory::getRaggedArrayHeaderType(builder);
mlir::IntegerType i32Ty = builder.getIntegerType(32);
mlir::Value one = builder.createIntegerConstant(loc, i32Ty, 1);
- auto coor1 = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(raggedTy.getType(1)), header, one);
+ auto coor1 = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(raggedTy.getType(1)), header,
+ one);
auto db = fir::LoadOp::create(builder, loc, coor1);
mlir::Type eleTy =
fir::unwrapSequenceType(fir::unwrapRefType(db.getType()));
@@ -4338,16 +4346,17 @@ private:
mlir::Value buff = builder.createConvert(loc, buffTy, db);
mlir::Value two = builder.createIntegerConstant(loc, i32Ty, 2);
- auto coor2 = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(raggedTy.getType(2)), header, two);
+ auto coor2 = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(raggedTy.getType(2)), header,
+ two);
auto shBuff = fir::LoadOp::create(builder, loc, coor2);
mlir::IntegerType i64Ty = builder.getIntegerType(64);
mlir::IndexType idxTy = builder.getIndexType();
llvm::SmallVector<mlir::Value> extents;
for (std::remove_const_t<decltype(rank)> i = 0; i < rank; ++i) {
mlir::Value off = builder.createIntegerConstant(loc, i32Ty, i);
- auto coor = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(i64Ty), shBuff, off);
+ auto coor = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(i64Ty), shBuff, off);
auto ldExt = fir::LoadOp::create(builder, loc, coor);
extents.push_back(builder.createConvert(loc, idxTy, ldExt));
}
@@ -4391,16 +4400,16 @@ private:
}
fir::DoLoopOp loop;
if (innerArg) {
- loop = fir::DoLoopOp::create(builder,
- loc, zero, i.value(), one, isUnordered(),
+ loop = fir::DoLoopOp::create(
+ builder, loc, zero, i.value(), one, isUnordered(),
/*finalCount=*/false, mlir::ValueRange{innerArg});
innerArg = loop.getRegionIterArgs().front();
if (explicitSpaceIsActive())
explicitSpace->setInnerArg(0, innerArg);
} else {
loop = fir::DoLoopOp::create(builder, loc, zero, i.value(), one,
- isUnordered(),
- /*finalCount=*/false);
+ isUnordered(),
+ /*finalCount=*/false);
}
ivars.push_back(loop.getInductionVar());
loops.push_back(loop);
@@ -4468,18 +4477,20 @@ private:
implicitSpace->getMasks()) {
const std::size_t size = maskExprs.size() - 1;
auto genFalseBlock = [&](const auto *e, auto &&cond) {
- auto ifOp = fir::IfOp::create(builder,
- loc, mlir::TypeRange{innerArg.getType()}, fir::getBase(cond),
- /*withElseRegion=*/true);
+ auto ifOp = fir::IfOp::create(builder, loc,
+ mlir::TypeRange{innerArg.getType()},
+ fir::getBase(cond),
+ /*withElseRegion=*/true);
fir::ResultOp::create(builder, loc, ifOp.getResult(0));
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
fir::ResultOp::create(builder, loc, innerArg);
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
};
auto genTrueBlock = [&](const auto *e, auto &&cond) {
- auto ifOp = fir::IfOp::create(builder,
- loc, mlir::TypeRange{innerArg.getType()}, fir::getBase(cond),
- /*withElseRegion=*/true);
+ auto ifOp = fir::IfOp::create(builder, loc,
+ mlir::TypeRange{innerArg.getType()},
+ fir::getBase(cond),
+ /*withElseRegion=*/true);
fir::ResultOp::create(builder, loc, ifOp.getResult(0));
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
fir::ResultOp::create(builder, loc, innerArg);
@@ -4527,14 +4538,14 @@ private:
!seqTy.hasDynamicExtents()
? fir::AllocMemOp::create(builder, loc, type)
: fir::AllocMemOp::create(builder, loc, type, ".array.expr",
- mlir::ValueRange{}, shape);
+ mlir::ValueRange{}, shape);
fir::FirOpBuilder *bldr = &converter.getFirOpBuilder();
stmtCtx.attachCleanup(
[bldr, loc, temp]() { bldr->create<fir::FreeMemOp>(loc, temp); });
mlir::Value shapeOp = genShapeOp(shape);
return fir::ArrayLoadOp::create(builder, loc, seqTy, temp, shapeOp,
- /*slice=*/mlir::Value{},
- mlir::ValueRange{});
+ /*slice=*/mlir::Value{},
+ mlir::ValueRange{});
}
static fir::ShapeOp genShapeOp(mlir::Location loc, fir::FirOpBuilder &builder,
@@ -4883,14 +4894,14 @@ private:
fir::dyn_cast_ptrOrBoxEleTy(fir::getBase(exv).getType());
mlir::Type innerTy = fir::unwrapSequenceType(baseTy);
operands.emplace_back([=](IterSpace iters) -> ExtValue {
- mlir::Value coord = fir::CoordinateOp::create(builder,
- loc, fir::ReferenceType::get(innerTy), fir::getBase(exv),
- iters.iterVec());
+ mlir::Value coord = fir::CoordinateOp::create(
+ builder, loc, fir::ReferenceType::get(innerTy),
+ fir::getBase(exv), iters.iterVec());
mlir::Value empty;
mlir::ValueRange emptyRange;
- return fir::EmboxOp::create(builder,
- loc, fir::ClassType::get(innerTy), coord, empty, empty,
- emptyRange, sourceBox);
+ return fir::EmboxOp::create(builder, loc,
+ fir::ClassType::get(innerTy), coord,
+ empty, empty, emptyRange, sourceBox);
});
} else {
ExtValue exv = asScalarRef(*expr);
@@ -4903,9 +4914,9 @@ private:
operands.emplace_back([=](IterSpace iters) -> ExtValue {
mlir::Value empty;
mlir::ValueRange emptyRange;
- return fir::EmboxOp::create(builder,
- loc, fir::ClassType::get(baseTy), fir::getBase(exv), empty,
- empty, emptyRange);
+ return fir::EmboxOp::create(
+ builder, loc, fir::ClassType::get(baseTy),
+ fir::getBase(exv), empty, empty, emptyRange);
});
}
}
@@ -5097,8 +5108,8 @@ private:
return exv.match(
[&](const fir::CharBoxValue &cb) -> ExtValue {
mlir::Value len = cb.getLen();
- auto mem =
- fir::AllocaOp::create(builder, loc, toType, mlir::ValueRange{len});
+ auto mem = fir::AllocaOp::create(builder, loc, toType,
+ mlir::ValueRange{len});
fir::CharBoxValue result(mem, len);
fir::factory::CharacterExprHelper{builder, loc}.createAssign(
ExtValue{result}, exv);
@@ -5469,11 +5480,11 @@ private:
if (destShape[0] != savedDestShape[dim]) {
// Not the same, so choose the smaller value.
mlir::Location loc = getLoc();
- auto cmp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::sgt, destShape[0],
- savedDestShape[dim]);
- auto sel = mlir::arith::SelectOp::create(builder,
- loc, cmp, savedDestShape[dim], destShape[0]);
+ auto cmp = mlir::arith::CmpIOp::create(builder, loc,
+ mlir::arith::CmpIPredicate::sgt,
+ destShape[0], savedDestShape[dim]);
+ auto sel = mlir::arith::SelectOp::create(
+ builder, loc, cmp, savedDestShape[dim], destShape[0]);
savedDestShape[dim] = sel;
destShape = savedDestShape;
}
@@ -5549,12 +5560,12 @@ private:
// FIXME: must use the lower bound of this component.
auto arrLowerBound =
atBase ? getLBound(arrayExv, subsIndex, one) : one;
- auto initial = mlir::arith::SubIOp::create(builder,
- loc, lowerBound, arrLowerBound);
- auto prod = mlir::arith::MulIOp::create(builder,
- loc, impliedIter, stride);
- auto result =
- mlir::arith::AddIOp::create(builder, loc, initial, prod);
+ auto initial = mlir::arith::SubIOp::create(
+ builder, loc, lowerBound, arrLowerBound);
+ auto prod = mlir::arith::MulIOp::create(
+ builder, loc, impliedIter, stride);
+ auto result = mlir::arith::AddIOp::create(builder, loc,
+ initial, prod);
newIters.setIndexValue(subsIndex, result);
return newIters;
};
@@ -5588,8 +5599,8 @@ private:
// using the base array's lower bound value.
mlir::Value lb = fir::factory::readLowerBound(
builder, loc, arrayExv, subsIndex, one);
- auto origin = mlir::arith::SubIOp::create(builder,
- loc, idxTy, val, lb);
+ auto origin = mlir::arith::SubIOp::create(builder, loc,
+ idxTy, val, lb);
newIters.setIndexValue(subsIndex, origin);
return newIters;
};
@@ -5623,8 +5634,8 @@ private:
// Normalize `e` by subtracting the declared lbound.
mlir::Value lb = fir::factory::readLowerBound(
builder, loc, arrayExv, subsIndex, one);
- mlir::Value ivAdj =
- mlir::arith::SubIOp::create(builder, loc, idxTy, iv, lb);
+ mlir::Value ivAdj = mlir::arith::SubIOp::create(
+ builder, loc, idxTy, iv, lb);
// Add lbound adjusted value of `e` to the iteration vector
// (except when creating a box because the iteration vector
// is empty).
@@ -5642,7 +5653,7 @@ private:
mlir::Value lb = fir::factory::readLowerBound(
builder, loc, arrayExv, subsIndex, one);
result = mlir::arith::SubIOp::create(builder, loc, idxTy,
- result, lb);
+ result, lb);
pc = [=](IterSpace iters) {
IterationSpace newIters = currentPC(iters);
newIters.insertIndexValue(subsIndex, result);
@@ -5770,14 +5781,14 @@ private:
mlir::Value zero = builder.createIntegerConstant(loc, iTy, 0);
auto size =
mlir::arith::SubIOp::create(builder, loc, cast, substringBounds[0]);
- auto cmp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::sgt, size, zero);
+ auto cmp = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::sgt, size, zero);
// size = MAX(upper - (lower - 1), 0)
substringBounds[1] =
mlir::arith::SelectOp::create(builder, loc, cmp, size, zero);
- slice = fir::SliceOp::create(builder,
- loc, padSlice(components.trips, shape), components.suffixComponents,
- substringBounds);
+ slice = fir::SliceOp::create(
+ builder, loc, padSlice(components.trips, shape),
+ components.suffixComponents, substringBounds);
} else {
slice = builder.createSlice(loc, extMemref, components.trips,
components.suffixComponents);
@@ -5849,8 +5860,8 @@ private:
// ArrayCoorOp does not expect zero based indices.
llvm::SmallVector<mlir::Value> indices = fir::factory::originateIndices(
loc, builder, memref.getType(), shape, iters.iterVec());
- mlir::Value coor = fir::ArrayCoorOp::create(builder,
- loc, refEleTy, memref, shape, slice, indices,
+ mlir::Value coor = fir::ArrayCoorOp::create(
+ builder, loc, refEleTy, memref, shape, slice, indices,
fir::getTypeParams(extMemref));
if (auto charTy = mlir::dyn_cast<fir::CharacterType>(eleTy)) {
llvm::SmallVector<mlir::Value> substringBounds;
@@ -5869,16 +5880,17 @@ private:
builder, loc, extMemref, coor, slice);
};
}
- auto arrLoad = fir::ArrayLoadOp::create(builder,
- loc, arrTy, memref, shape, slice, fir::getTypeParams(extMemref));
+ auto arrLoad =
+ fir::ArrayLoadOp::create(builder, loc, arrTy, memref, shape, slice,
+ fir::getTypeParams(extMemref));
if (CrayPtr) {
mlir::Type ptrTy = CrayPtr.getType();
mlir::Value cnvrt = Fortran::lower::addCrayPointerInst(
loc, builder, CrayPtr, ptrTy, memref.getType());
auto addr = fir::LoadOp::create(builder, loc, cnvrt);
- arrLoad = fir::ArrayLoadOp::create(builder, loc, arrTy, addr, shape, slice,
- fir::getTypeParams(extMemref));
+ arrLoad = fir::ArrayLoadOp::create(builder, loc, arrTy, addr, shape,
+ slice, fir::getTypeParams(extMemref));
}
mlir::Value arrLd = arrLoad.getResult();
@@ -5906,9 +5918,9 @@ private:
mlir::Type eleTy = fir::applyPathToType(resTy, iters.iterVec());
mlir::Type refEleTy =
fir::isa_ref_type(eleTy) ? eleTy : builder.getRefType(eleTy);
- auto arrModify = fir::ArrayModifyOp::create(builder,
- loc, mlir::TypeRange{refEleTy, resTy}, innerArg, iters.iterVec(),
- destination.getTypeparams());
+ auto arrModify = fir::ArrayModifyOp::create(
+ builder, loc, mlir::TypeRange{refEleTy, resTy}, innerArg,
+ iters.iterVec(), destination.getTypeparams());
return abstractArrayExtValue(arrModify.getResult(1));
};
}
@@ -5932,11 +5944,11 @@ private:
mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
if (isAdjustedArrayElementType(eleTy)) {
mlir::Type eleRefTy = builder.getRefType(eleTy);
- base = fir::ArrayAccessOp::create(builder,
- loc, eleRefTy, arrLd, iters.iterVec(), arrLdTypeParams);
+ base = fir::ArrayAccessOp::create(builder, loc, eleRefTy, arrLd,
+ iters.iterVec(), arrLdTypeParams);
} else {
- base = fir::ArrayFetchOp::create(builder,
- loc, eleTy, arrLd, iters.iterVec(), arrLdTypeParams);
+ base = fir::ArrayFetchOp::create(builder, loc, eleTy, arrLd,
+ iters.iterVec(), arrLdTypeParams);
}
mlir::Value temp =
builder.createTemporary(loc, base.getType(),
@@ -5953,8 +5965,8 @@ private:
mlir::Type eleTy = fir::applyPathToType(arrTy, iters.iterVec());
if (isAdjustedArrayElementType(eleTy)) {
mlir::Type eleRefTy = builder.getRefType(eleTy);
- mlir::Value arrayOp = fir::ArrayAccessOp::create(builder,
- loc, eleRefTy, arrLd, iters.iterVec(), arrLdTypeParams);
+ mlir::Value arrayOp = fir::ArrayAccessOp::create(
+ builder, loc, eleRefTy, arrLd, iters.iterVec(), arrLdTypeParams);
if (auto charTy = mlir::dyn_cast<fir::CharacterType>(eleTy)) {
llvm::SmallVector<mlir::Value> substringBounds;
populateBounds(substringBounds, components.substring);
@@ -5969,8 +5981,8 @@ private:
return fir::factory::arraySectionElementToExtendedValue(
builder, loc, extMemref, arrayOp, slice);
}
- auto arrFetch = fir::ArrayFetchOp::create(builder,
- loc, eleTy, arrLd, iters.iterVec(), arrLdTypeParams);
+ auto arrFetch = fir::ArrayFetchOp::create(
+ builder, loc, eleTy, arrLd, iters.iterVec(), arrLdTypeParams);
return fir::factory::arraySectionElementToExtendedValue(
builder, loc, extMemref, arrFetch, slice);
};
@@ -6009,8 +6021,8 @@ private:
mlir::Value memref = fir::getBase(exv);
mlir::Value shape = builder.createShape(loc, exv);
mlir::Value noSlice;
- auto arrLoad = fir::ArrayLoadOp::create(builder,
- loc, arrType, memref, shape, noSlice, fir::getTypeParams(exv));
+ auto arrLoad = fir::ArrayLoadOp::create(
+ builder, loc, arrType, memref, shape, noSlice, fir::getTypeParams(exv));
mlir::Operation::operand_range arrLdTypeParams = arrLoad.getTypeparams();
mlir::Value arrLd = arrLoad.getResult();
// Mark the load to tell later passes it is unsafe to use this array_load
@@ -6025,8 +6037,8 @@ private:
// By value semantics.
auto cc = [=](IterSpace iters) -> ExtValue {
- auto arrFetch = fir::ArrayFetchOp::create(builder,
- loc, eleType, arrLd, iters.iterVec(), arrLdTypeParams);
+ auto arrFetch = fir::ArrayFetchOp::create(
+ builder, loc, eleType, arrLd, iters.iterVec(), arrLdTypeParams);
return fir::factory::arraySectionElementToExtendedValue(
builder, loc, exv, arrFetch, noSlice);
};
@@ -6178,8 +6190,8 @@ private:
mlir::Type eleRefTy = builder.getRefType(eleTy);
mlir::Type resRefTy = builder.getRefType(resTy);
mlir::Value nullPtr = builder.createNullConstant(loc, resRefTy);
- auto offset = fir::CoordinateOp::create(builder,
- loc, eleRefTy, nullPtr, mlir::ValueRange{multiplier});
+ auto offset = fir::CoordinateOp::create(builder, loc, eleRefTy, nullPtr,
+ mlir::ValueRange{multiplier});
return builder.createConvert(loc, idxTy, offset);
}
@@ -6194,7 +6206,7 @@ private:
void createCallMemcpy(llvm::ArrayRef<mlir::Value> args, bool isVolatile) {
mlir::Location loc = getLoc();
mlir::LLVM::MemcpyOp::create(builder, loc, args[0], args[1], args[2],
- isVolatile);
+ isVolatile);
}
// Construct code to check for a buffer overrun and realloc the buffer when
@@ -6204,10 +6216,10 @@ private:
mlir::Value eleSz) {
mlir::Location loc = getLoc();
mlir::func::FuncOp reallocFunc = fir::factory::getRealloc(builder);
- auto cond = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::sle, bufferSize, needed);
+ auto cond = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::sle, bufferSize, needed);
auto ifOp = fir::IfOp::create(builder, loc, mem.getType(), cond,
- /*withElseRegion=*/true);
+ /*withElseRegion=*/true);
auto insPt = builder.saveInsertionPoint();
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
// Not enough space, resize the buffer.
@@ -6215,12 +6227,13 @@ private:
mlir::Value two = builder.createIntegerConstant(loc, idxTy, 2);
auto newSz = mlir::arith::MulIOp::create(builder, loc, needed, two);
fir::StoreOp::create(builder, loc, newSz, buffSize);
- mlir::Value byteSz = mlir::arith::MulIOp::create(builder, loc, newSz, eleSz);
+ mlir::Value byteSz =
+ mlir::arith::MulIOp::create(builder, loc, newSz, eleSz);
mlir::SymbolRefAttr funcSymAttr =
builder.getSymbolRefAttr(reallocFunc.getName());
mlir::FunctionType funcTy = reallocFunc.getFunctionType();
- auto newMem = fir::CallOp::create(builder,
- loc, funcSymAttr, funcTy.getResults(),
+ auto newMem = fir::CallOp::create(
+ builder, loc, funcSymAttr, funcTy.getResults(),
llvm::ArrayRef<mlir::Value>{
builder.createConvert(loc, funcTy.getInputs()[0], mem),
builder.createConvert(loc, funcTy.getInputs()[1], byteSz)});
@@ -6285,7 +6298,7 @@ private:
}
}
auto coor = fir::CoordinateOp::create(builder, loc, refTy, buff,
- mlir::ValueRange{off});
+ mlir::ValueRange{off});
return builder.createConvert(loc, eleRefTy, coor);
};
@@ -6326,7 +6339,7 @@ private:
mlir::Value buff =
builder.createConvert(loc, fir::HeapType::get(resTy), mem);
auto buffi = fir::CoordinateOp::create(builder, loc, eleRefTy, buff,
- mlir::ValueRange{off});
+ mlir::ValueRange{off});
fir::factory::genScalarAssignment(
builder, loc,
[&]() -> ExtValue {
@@ -6404,7 +6417,7 @@ private:
mlir::Type eleTy = fir::unwrapSequenceType(seqTy);
auto loop =
fir::DoLoopOp::create(builder, loc, lo, up, step, /*unordered=*/false,
- /*finalCount=*/false, mem);
+ /*finalCount=*/false, mem);
// create a new binding for x.name(), to ac-do-variable, to the iteration
// value.
symMap.pushImpliedDoBinding(toStringRef(x.name()), loop.getInductionVar());
@@ -6484,8 +6497,8 @@ private:
} else {
mlir::Value initBuffSz =
builder.createIntegerConstant(loc, idxTy, clInitialBufferSize);
- mem = fir::AllocMemOp::create(builder,
- loc, eleTy, /*typeparams=*/mlir::ValueRange{}, initBuffSz);
+ mem = fir::AllocMemOp::create(
+ builder, loc, eleTy, /*typeparams=*/mlir::ValueRange{}, initBuffSz);
fir::StoreOp::create(builder, loc, initBuffSz, buffSize);
}
} else {
@@ -6806,9 +6819,8 @@ private:
: one;
mlir::Value val = builder.createConvert(
loc, idxTy, subscriptVal);
- mlir::Value ivAdj =
- mlir::arith::SubIOp::create(builder,
- loc, idxTy, val, lb);
+ mlir::Value ivAdj = mlir::arith::SubIOp::create(
+ builder, loc, idxTy, val, lb);
componentsToAdd.push_back(
builder.createConvert(loc, idxTy, ivAdj));
},
@@ -6830,8 +6842,9 @@ private:
converter.getRecordTypeFieldName(getLastSym(*x));
if (auto recTy = mlir::dyn_cast<fir::RecordType>(ty)) {
ty = recTy.getType(name);
- auto fld = fir::FieldIndexOp::create(builder,
- loc, fieldTy, name, recTy, fir::getTypeParams(arrayExv));
+ auto fld = fir::FieldIndexOp::create(
+ builder, loc, fieldTy, name, recTy,
+ fir::getTypeParams(arrayExv));
addComponentList(ty, {fld});
if (index != revPath.size() - 1 || !isPointerAssignment()) {
// Need an intermediate dereference if the boxed value
@@ -6852,8 +6865,9 @@ private:
ty = fir::unwrapRefType(boxTy.getEleTy());
auto recTy = mlir::cast<fir::RecordType>(ty);
ty = recTy.getType(name);
- auto fld = fir::FieldIndexOp::create(builder,
- loc, fieldTy, name, recTy, fir::getTypeParams(arrayExv));
+ auto fld = fir::FieldIndexOp::create(
+ builder, loc, fieldTy, name, recTy,
+ fir::getTypeParams(arrayExv));
extendComponent(components, ty, {fld});
} else {
TODO(loc, "other component type");
@@ -6896,8 +6910,8 @@ private:
mlir::Value innerArg = esp->findArgumentOfLoad(load);
if (isAdjustedArrayElementType(eleTy)) {
mlir::Type eleRefTy = builder.getRefType(eleTy);
- auto arrayOp = fir::ArrayAccessOp::create(builder,
- loc, eleRefTy, innerArg, iters.iterVec(),
+ auto arrayOp = fir::ArrayAccessOp::create(
+ builder, loc, eleRefTy, innerArg, iters.iterVec(),
fir::factory::getTypeParams(loc, builder, load));
if (auto charTy = mlir::dyn_cast<fir::CharacterType>(eleTy)) {
mlir::Value dstLen = fir::factory::genLenOfCharacter(
@@ -6924,9 +6938,9 @@ private:
if (!eleBoxTy || !mlir::isa<fir::BoxType>(eleBoxTy))
TODO(loc, "assignment in a FORALL involving a designator with a "
"POINTER or ALLOCATABLE component part-ref");
- auto arrayOp = fir::ArrayAccessOp::create(builder,
- loc, builder.getRefType(eleBoxTy), innerArg, iters.iterVec(),
- fir::factory::getTypeParams(loc, builder, load));
+ auto arrayOp = fir::ArrayAccessOp::create(
+ builder, loc, builder.getRefType(eleBoxTy), innerArg,
+ iters.iterVec(), fir::factory::getTypeParams(loc, builder, load));
mlir::Value addr = components.getExtendCoorRef()(arrayOp);
components.resetExtendCoorRef();
// When the lhs is a boxed value and the context is not a pointer
@@ -6941,13 +6955,13 @@ private:
}
auto ele = convertElementForUpdate(loc, eleTy, iters.getElement());
fir::StoreOp::create(builder, loc, ele, addr);
- auto amend = fir::ArrayAmendOp::create(builder,
- loc, innerArg.getType(), innerArg, arrayOp);
+ auto amend = fir::ArrayAmendOp::create(
+ builder, loc, innerArg.getType(), innerArg, arrayOp);
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), amend);
}
auto ele = convertElementForUpdate(loc, eleTy, iters.getElement());
- auto update = fir::ArrayUpdateOp::create(builder,
- loc, innerArg.getType(), innerArg, ele, iters.iterVec(),
+ auto update = fir::ArrayUpdateOp::create(
+ builder, loc, innerArg.getType(), innerArg, ele, iters.iterVec(),
fir::factory::getTypeParams(loc, builder, load));
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), update);
};
@@ -6961,9 +6975,9 @@ private:
mlir::Value innerArg = explicitSpace->findArgumentOfLoad(load);
mlir::Type refEleTy =
fir::isa_ref_type(eleTy) ? eleTy : builder.getRefType(eleTy);
- auto arrModify = fir::ArrayModifyOp::create(builder,
- loc, mlir::TypeRange{refEleTy, innerArg.getType()}, innerArg,
- iters.iterVec(), load.getTypeparams());
+ auto arrModify = fir::ArrayModifyOp::create(
+ builder, loc, mlir::TypeRange{refEleTy, innerArg.getType()},
+ innerArg, iters.iterVec(), load.getTypeparams());
return arrayLoadExtValue(builder, loc, load, iters.iterVec(),
arrModify.getResult(1));
};
@@ -6974,8 +6988,8 @@ private:
isAdjustedArrayElementType(eleTy)) {
mlir::Type resTy = builder.getRefType(eleTy);
// Use array element reference semantics.
- auto access = fir::ArrayAccessOp::create(builder,
- loc, resTy, load, iters.iterVec(),
+ auto access = fir::ArrayAccessOp::create(
+ builder, loc, resTy, load, iters.iterVec(),
fir::factory::getTypeParams(loc, builder, load));
mlir::Value newBase = access;
if (fir::isa_char(eleTy)) {
@@ -6997,8 +7011,8 @@ private:
if (!eleBoxTy || !mlir::isa<fir::BoxType>(eleBoxTy))
TODO(loc, "assignment in a FORALL involving a designator with a "
"POINTER or ALLOCATABLE component part-ref");
- auto access = fir::ArrayAccessOp::create(builder,
- loc, builder.getRefType(eleBoxTy), load, iters.iterVec(),
+ auto access = fir::ArrayAccessOp::create(
+ builder, loc, builder.getRefType(eleBoxTy), load, iters.iterVec(),
fir::factory::getTypeParams(loc, builder, load));
mlir::Value addr = components.getExtendCoorRef()(access);
components.resetExtendCoorRef();
@@ -7010,8 +7024,8 @@ private:
// Rhs is a regular expression that will need to be boxed before
// assigning to the boxed variable.
auto typeParams = fir::factory::getTypeParams(loc, builder, load);
- auto access = fir::ArrayAccessOp::create(builder,
- loc, builder.getRefType(eleTy), load, iters.iterVec(),
+ auto access = fir::ArrayAccessOp::create(
+ builder, loc, builder.getRefType(eleTy), load, iters.iterVec(),
typeParams);
auto addr = components.getExtendCoorRef()(access);
components.resetExtendCoorRef();
@@ -7026,13 +7040,13 @@ private:
"component");
mlir::Value embox =
fir::EmboxOp::create(builder, loc, boxTy, ptrAddr,
- /*shape=*/mlir::Value{},
- /*slice=*/mlir::Value{}, typeParams);
+ /*shape=*/mlir::Value{},
+ /*slice=*/mlir::Value{}, typeParams);
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), embox);
}
}
- auto fetch = fir::ArrayFetchOp::create(builder,
- loc, eleTy, load, iters.iterVec(), load.getTypeparams());
+ auto fetch = fir::ArrayFetchOp::create(
+ builder, loc, eleTy, load, iters.iterVec(), load.getTypeparams());
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), fetch);
};
return [=](IterSpace iters) mutable { return lambda(pc(iters)); };
@@ -7541,24 +7555,25 @@ fir::ExtendedValue Fortran::lower::updateBoxForParentComponent(
if (op) {
if (auto embox = mlir::dyn_cast<fir::EmboxOp>(op)) {
- auto newBox = fir::EmboxOp::create(builder,
- loc, fir::BoxType::get(actualTy), embox.getMemref(), embox.getShape(),
- embox.getSlice(), embox.getTypeparams());
+ auto newBox = fir::EmboxOp::create(
+ builder, loc, fir::BoxType::get(actualTy), embox.getMemref(),
+ embox.getShape(), embox.getSlice(), embox.getTypeparams());
return fir::substBase(box, newBox);
}
if (auto rebox = mlir::dyn_cast<fir::ReboxOp>(op)) {
- auto newBox = fir::ReboxOp::create(builder,
- loc, fir::BoxType::get(actualTy), rebox.getBox(), rebox.getShape(),
- rebox.getSlice());
+ auto newBox = fir::ReboxOp::create(
+ builder, loc, fir::BoxType::get(actualTy), rebox.getBox(),
+ rebox.getShape(), rebox.getSlice());
return fir::substBase(box, newBox);
}
}
mlir::Value empty;
mlir::ValueRange emptyRange;
- return fir::ReboxOp::create(builder, loc, fir::BoxType::get(actualTy), boxBase,
- /*shape=*/empty,
- /*slice=*/empty);
+ return fir::ReboxOp::create(builder, loc, fir::BoxType::get(actualTy),
+ boxBase,
+ /*shape=*/empty,
+ /*slice=*/empty);
}
fir::ExtendedValue Fortran::lower::createBoxValue(
@@ -7650,8 +7665,8 @@ fir::ArrayLoadOp genArrayLoad(mlir::Location loc,
mlir::Value shapeOp = builder.createShape(loc, exv);
mlir::Type arrTy = fir::dyn_cast_ptrOrBoxEleTy(addr.getType());
return fir::ArrayLoadOp::create(builder, loc, arrTy, addr, shapeOp,
- /*slice=*/mlir::Value{},
- fir::getTypeParams(exv));
+ /*slice=*/mlir::Value{},
+ fir::getTypeParams(exv));
}
template <>
fir::ArrayLoadOp
@@ -7699,8 +7714,8 @@ void Fortran::lower::createArrayMergeStores(
if (std::optional<fir::ArrayLoadOp> ldOpt = esp.getLhsLoad(i.index())) {
fir::ArrayLoadOp load = *ldOpt;
fir::ArrayMergeStoreOp::create(builder, loc, load, i.value(),
- load.getMemref(), load.getSlice(),
- load.getTypeparams());
+ load.getMemref(), load.getSlice(),
+ load.getTypeparams());
}
if (esp.loopCleanup) {
(*esp.loopCleanup)(builder);
@@ -7723,11 +7738,11 @@ mlir::Value Fortran::lower::addCrayPointerInst(mlir::Location loc,
mlir::ValueRange emptyRange;
auto boxTy = fir::BoxType::get(ptrTy);
auto box = fir::EmboxOp::create(builder, loc, boxTy, ptrVal, empty, empty,
- emptyRange);
- mlir::Value addrof =
- (mlir::isa<fir::ReferenceType>(ptrTy))
- ? fir::BoxAddrOp::create(builder, loc, ptrTy, box)
- : fir::BoxAddrOp::create(builder, loc, builder.getRefType(ptrTy), box);
+ emptyRange);
+ mlir::Value addrof = (mlir::isa<fir::ReferenceType>(ptrTy))
+ ? fir::BoxAddrOp::create(builder, loc, ptrTy, box)
+ : fir::BoxAddrOp::create(
+ builder, loc, builder.getRefType(ptrTy), box);
auto refPtrTy =
builder.getRefType(fir::PointerType::get(fir::dyn_cast_ptrEleTy(pteTy)));
diff --git a/flang/lib/Lower/ConvertExprToHLFIR.cpp b/flang/lib/Lower/ConvertExprToHLFIR.cpp
index a709c7a36..46be11124 100644
--- a/flang/lib/Lower/ConvertExprToHLFIR.cpp
+++ b/flang/lib/Lower/ConvertExprToHLFIR.cpp
@@ -312,8 +312,8 @@ private:
// hlfir.elemental_addr.
if (auto elementalAddrOp = getVectorSubscriptElementAddrOp())
builder.setInsertionPointToEnd(&elementalAddrOp->getBody().front());
- auto designate = hlfir::DesignateOp::create(builder,
- getLoc(), designatorType, partInfo.base.value().getBase(),
+ auto designate = hlfir::DesignateOp::create(
+ builder, getLoc(), designatorType, partInfo.base.value().getBase(),
partInfo.componentName, partInfo.componentShape, partInfo.subscripts,
partInfo.substring, partInfo.complexPart, partInfo.resultShape,
partInfo.typeParams, attributes);
@@ -442,8 +442,8 @@ private:
} else {
// Compute "len = max(ub-lb+1,0)" (Fortran 2018 9.4.1).
mlir::Value one = builder.createIntegerConstant(loc, idxTy, 1);
- auto boundsDiff = mlir::arith::SubIOp::create(builder,
- loc, partInfo.substring[1], partInfo.substring[0]);
+ auto boundsDiff = mlir::arith::SubIOp::create(
+ builder, loc, partInfo.substring[1], partInfo.substring[0]);
auto rawLen = mlir::arith::AddIOp::create(builder, loc, boundsDiff, one);
partInfo.typeParams[0] =
fir::factory::genMaxWithZero(builder, loc, rawLen);
@@ -836,8 +836,8 @@ private:
assert(partInfo.base.has_value() &&
"vector subscripted part must have a base");
mlir::Value mold = *partInfo.base;
- auto elementalAddrOp = hlfir::ElementalAddrOp::create(builder,
- loc, shape, mold, mlir::ValueRange{},
+ auto elementalAddrOp = hlfir::ElementalAddrOp::create(
+ builder, loc, shape, mold, mlir::ValueRange{},
/*isUnordered=*/true);
setVectorSubscriptElementAddrOp(elementalAddrOp);
builder.setInsertionPointToEnd(&elementalAddrOp.getBody().front());
@@ -1034,7 +1034,7 @@ struct BinaryOp {};
rhs)}; \
} else { \
return hlfir::EntityWithAttributes{ \
- GenBinFirOp::create(builder, loc, lhs, rhs)}; \
+ GenBinFirOp::create(builder, loc, lhs, rhs)}; \
} \
} \
};
@@ -1219,8 +1219,8 @@ struct BinaryOp<Fortran::evaluate::Relational<
fir::FirOpBuilder &builder,
const Op &op, hlfir::Entity lhs,
hlfir::Entity rhs) {
- auto cmp = mlir::arith::CmpIOp::create(builder,
- loc, translateSignedRelational(op.opr), lhs, rhs);
+ auto cmp = mlir::arith::CmpIOp::create(
+ builder, loc, translateSignedRelational(op.opr), lhs, rhs);
return hlfir::EntityWithAttributes{cmp};
}
};
@@ -1241,8 +1241,8 @@ struct BinaryOp<Fortran::evaluate::Relational<
mlir::IntegerType::SignednessSemantics::Signless);
mlir::Value lhsSL = builder.createConvert(loc, signlessType, lhs);
mlir::Value rhsSL = builder.createConvert(loc, signlessType, rhs);
- auto cmp = mlir::arith::CmpIOp::create(builder,
- loc, translateUnsignedRelational(op.opr), lhsSL, rhsSL);
+ auto cmp = mlir::arith::CmpIOp::create(
+ builder, loc, translateUnsignedRelational(op.opr), lhsSL, rhsSL);
return hlfir::EntityWithAttributes{cmp};
}
};
@@ -1256,8 +1256,8 @@ struct BinaryOp<Fortran::evaluate::Relational<
fir::FirOpBuilder &builder,
const Op &op, hlfir::Entity lhs,
hlfir::Entity rhs) {
- auto cmp = mlir::arith::CmpFOp::create(builder,
- loc, translateFloatRelational(op.opr), lhs, rhs);
+ auto cmp = mlir::arith::CmpFOp::create(
+ builder, loc, translateFloatRelational(op.opr), lhs, rhs);
return hlfir::EntityWithAttributes{cmp};
}
};
@@ -1271,8 +1271,8 @@ struct BinaryOp<Fortran::evaluate::Relational<
fir::FirOpBuilder &builder,
const Op &op, hlfir::Entity lhs,
hlfir::Entity rhs) {
- auto cmp = fir::CmpcOp::create(builder,
- loc, translateFloatRelational(op.opr), lhs, rhs);
+ auto cmp = fir::CmpcOp::create(builder, loc,
+ translateFloatRelational(op.opr), lhs, rhs);
return hlfir::EntityWithAttributes{cmp};
}
};
@@ -1318,11 +1318,11 @@ struct BinaryOp<Fortran::evaluate::LogicalOperation<KIND>> {
return hlfir::EntityWithAttributes{
mlir::arith::OrIOp::create(builder, loc, i1Lhs, i1Rhs)};
case Fortran::evaluate::LogicalOperator::Eqv:
- return hlfir::EntityWithAttributes{mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::eq, i1Lhs, i1Rhs)};
+ return hlfir::EntityWithAttributes{mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::eq, i1Lhs, i1Rhs)};
case Fortran::evaluate::LogicalOperator::Neqv:
- return hlfir::EntityWithAttributes{mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::ne, i1Lhs, i1Rhs)};
+ return hlfir::EntityWithAttributes{mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::ne, i1Lhs, i1Rhs)};
case Fortran::evaluate::LogicalOperator::Not:
// lib/evaluate expression for .NOT. is Fortran::evaluate::Not<KIND>.
llvm_unreachable(".NOT. is not a binary operator");
@@ -1822,8 +1822,8 @@ private:
// Allocate scalar temporary that will be initialized
// with the values specified by the constructor.
mlir::Value storagePtr = builder.createTemporary(loc, recTy);
- auto varOp = hlfir::EntityWithAttributes{hlfir::DeclareOp::create(builder,
- loc, storagePtr, "ctor.temp", /*shape=*/nullptr,
+ auto varOp = hlfir::EntityWithAttributes{hlfir::DeclareOp::create(
+ builder, loc, storagePtr, "ctor.temp", /*shape=*/nullptr,
/*typeparams=*/mlir::ValueRange{}, /*dummy_scope=*/nullptr,
fir::FortranVariableFlagsAttr{})};
@@ -1855,8 +1855,8 @@ private:
auto parentCompType = baseRecTy.getType(parentName);
assert(parentCompType && "failed to retrieve parent component type");
mlir::Type designatorType = builder.getRefType(parentCompType);
- mlir::Value newParent = hlfir::DesignateOp::create(builder,
- loc, designatorType, currentParent, parentName,
+ mlir::Value newParent = hlfir::DesignateOp::create(
+ builder, loc, designatorType, currentParent, parentName,
/*compShape=*/mlir::Value{}, hlfir::DesignateOp::Subscripts{},
/*substring=*/mlir::ValueRange{},
/*complexPart=*/std::nullopt,
@@ -1912,8 +1912,8 @@ private:
extraAttributeFlags);
// Get the component designator.
- auto lhs = hlfir::DesignateOp::create(builder,
- loc, designatorType, baseOp, name, compShape,
+ auto lhs = hlfir::DesignateOp::create(
+ builder, loc, designatorType, baseOp, name, compShape,
hlfir::DesignateOp::Subscripts{},
/*substring=*/mlir::ValueRange{},
/*complexPart=*/std::nullopt,
@@ -1998,9 +1998,9 @@ private:
hlfir::genTypeAndKindConvert(loc, builder, rhs, lhs.getType(),
/*preserveLowerBounds=*/allowRealloc);
hlfir::AssignOp::create(builder, loc, rhsCastAndCleanup.first, lhs,
- allowRealloc,
- allowRealloc ? keepLhsLength : false,
- /*temporary_lhs=*/true);
+ allowRealloc,
+ allowRealloc ? keepLhsLength : false,
+ /*temporary_lhs=*/true);
if (rhsCastAndCleanup.second)
(*rhsCastAndCleanup.second)();
};
diff --git a/flang/lib/Lower/ConvertProcedureDesignator.cpp b/flang/lib/Lower/ConvertProcedureDesignator.cpp
index e46717070..d4c535d71 100644
--- a/flang/lib/Lower/ConvertProcedureDesignator.cpp
+++ b/flang/lib/Lower/ConvertProcedureDesignator.cpp
@@ -124,8 +124,8 @@ static hlfir::EntityWithAttributes designateProcedurePointerComponent(
if (!fieldType)
TODO(loc, "passing type bound procedure (extension)");
mlir::Type designatorType = fir::ReferenceType::get(fieldType);
- mlir::Value compRef = hlfir::DesignateOp::create(builder,
- loc, designatorType, base, fieldName,
+ mlir::Value compRef = hlfir::DesignateOp::create(
+ builder, loc, designatorType, base, fieldName,
/*compShape=*/mlir::Value{}, hlfir::DesignateOp::Subscripts{},
/*substring=*/mlir::ValueRange{},
/*complexPart=*/std::nullopt,
@@ -174,8 +174,8 @@ hlfir::EntityWithAttributes Fortran::lower::convertProcedureDesignatorToHLFIR(
mlir::Type boxTy =
Fortran::lower::getUntypedBoxProcType(&converter.getMLIRContext());
if (auto host = Fortran::lower::argumentHostAssocs(converter, funcAddr))
- funcAddr = fir::EmboxProcOp::create(builder,
- loc, boxTy, llvm::ArrayRef<mlir::Value>{funcAddr, host});
+ funcAddr = fir::EmboxProcOp::create(
+ builder, loc, boxTy, llvm::ArrayRef<mlir::Value>{funcAddr, host});
else
funcAddr = fir::EmboxProcOp::create(builder, loc, boxTy, funcAddr);
}
diff --git a/flang/lib/Lower/ConvertVariable.cpp b/flang/lib/Lower/ConvertVariable.cpp
index 11e0feb88..647bd0d07 100644
--- a/flang/lib/Lower/ConvertVariable.cpp
+++ b/flang/lib/Lower/ConvertVariable.cpp
@@ -313,7 +313,7 @@ mlir::Value Fortran::lower::genInitialDataTarget(
// Create a fir.rebox to set the attribute correctly, and use targetShift
// to preserve the target lower bounds if any.
return fir::ReboxOp::create(builder, loc, boxType, targetBox, targetShift,
- /*slice=*/mlir::Value{});
+ /*slice=*/mlir::Value{});
}
/// Generate default initial value for a derived type object \p sym with mlir
@@ -383,11 +383,11 @@ static mlir::Value genComponentDefaultInit(
componentValue = builder.createConvert(loc, componentTy, componentValue);
auto fieldTy = fir::FieldType::get(recTy.getContext());
// FIXME: type parameters must come from the derived-type-spec
- auto field = fir::FieldIndexOp::create(builder,
- loc, fieldTy, name, recTy,
- /*typeParams=*/mlir::ValueRange{} /*TODO*/);
- return fir::InsertValueOp::create(builder,
- loc, recTy, insertInto, componentValue,
+ auto field =
+ fir::FieldIndexOp::create(builder, loc, fieldTy, name, recTy,
+ /*typeParams=*/mlir::ValueRange{} /*TODO*/);
+ return fir::InsertValueOp::create(
+ builder, loc, recTy, insertInto, componentValue,
builder.getArrayAttr(field.getAttributes()));
}
@@ -453,8 +453,8 @@ static mlir::Value genDefaultInitializerValue(
rangeBounds.push_back(0);
rangeBounds.push_back(extent - 1);
}
- return fir::InsertOnRangeOp::create(builder,
- loc, sequenceType, arrayInitialValue, initialValue,
+ return fir::InsertOnRangeOp::create(
+ builder, loc, sequenceType, arrayInitialValue, initialValue,
builder.getIndexVectorAttr(rangeBounds));
}
return initialValue;
@@ -691,7 +691,7 @@ static void instantiateGlobal(Fortran::lower::AbstractConverter &converter,
global = defineGlobal(converter, var, globalName, linkage, dataAttr);
}
auto addrOf = fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
// The type of the global cannot be trusted to be the same as the one
// of the variable as some existing programs map common blocks to
// BIND(C) module variables (e.g. mpi_argv_null in MPI and MPI_F08).
@@ -768,11 +768,11 @@ static mlir::Value createNewLocal(Fortran::lower::AbstractConverter &converter,
indices.push_back(builder.createConvert(loc, idxTy, sh));
if (dataAttr.getValue() == cuf::DataAttribute::Shared)
return cuf::SharedMemoryOp::create(builder, loc, ty, nm, symNm, lenParams,
- indices);
+ indices);
if (!cuf::isCUDADeviceContext(builder.getRegion()))
return cuf::AllocOp::create(builder, loc, ty, nm, symNm, dataAttr,
- lenParams, indices);
+ lenParams, indices);
}
// Let the builder do all the heavy lifting.
@@ -833,9 +833,9 @@ initializeDeviceComponentAllocator(Fortran::lower::AbstractConverter &converter,
// Field found in the base record type.
auto fieldName = recTy.getTypeList()[fieldIdx].first;
fieldTy = recTy.getTypeList()[fieldIdx].second;
- mlir::Value fieldIndex = fir::FieldIndexOp::create(builder,
- loc, fir::FieldType::get(fieldTy.getContext()), fieldName,
- recTy,
+ mlir::Value fieldIndex = fir::FieldIndexOp::create(
+ builder, loc, fir::FieldType::get(fieldTy.getContext()),
+ fieldName, recTy,
/*typeParams=*/mlir::ValueRange{});
coordinates.push_back(fieldIndex);
} else {
@@ -846,19 +846,18 @@ initializeDeviceComponentAllocator(Fortran::lower::AbstractConverter &converter,
mlir::dyn_cast<fir::RecordType>(component.second)) {
fieldIdx = childRecTy.getFieldIndex(sym.name().ToString());
if (fieldIdx != std::numeric_limits<unsigned>::max()) {
- mlir::Value parentFieldIndex =
- fir::FieldIndexOp::create(builder,
- loc, fir::FieldType::get(childRecTy.getContext()),
- component.first, recTy,
- /*typeParams=*/mlir::ValueRange{});
+ mlir::Value parentFieldIndex = fir::FieldIndexOp::create(
+ builder, loc,
+ fir::FieldType::get(childRecTy.getContext()),
+ component.first, recTy,
+ /*typeParams=*/mlir::ValueRange{});
coordinates.push_back(parentFieldIndex);
auto fieldName = childRecTy.getTypeList()[fieldIdx].first;
fieldTy = childRecTy.getTypeList()[fieldIdx].second;
- mlir::Value childFieldIndex =
- fir::FieldIndexOp::create(builder,
- loc, fir::FieldType::get(fieldTy.getContext()),
- fieldName, childRecTy,
- /*typeParams=*/mlir::ValueRange{});
+ mlir::Value childFieldIndex = fir::FieldIndexOp::create(
+ builder, loc, fir::FieldType::get(fieldTy.getContext()),
+ fieldName, childRecTy,
+ /*typeParams=*/mlir::ValueRange{});
coordinates.push_back(childFieldIndex);
break;
}
@@ -879,14 +878,14 @@ initializeDeviceComponentAllocator(Fortran::lower::AbstractConverter &converter,
assert(coordinates.size() == 1 && "expect one coordinate");
auto field = mlir::dyn_cast<fir::FieldIndexOp>(
coordinates[0].getDefiningOp());
- comp = hlfir::DesignateOp::create(builder,
- loc, builder.getRefType(fieldTy), addr,
+ comp = hlfir::DesignateOp::create(
+ builder, loc, builder.getRefType(fieldTy), addr,
/*component=*/field.getFieldName(),
/*componentShape=*/mlir::Value{},
hlfir::DesignateOp::Subscripts{});
} else {
- comp = fir::CoordinateOp::create(builder,
- loc, builder.getRefType(fieldTy), base, coordinates);
+ comp = fir::CoordinateOp::create(
+ builder, loc, builder.getRefType(fieldTy), base, coordinates);
}
cuf::DataAttributeAttr dataAttr =
Fortran::lower::translateSymbolCUFDataAttribute(
@@ -934,7 +933,7 @@ void Fortran::lower::defaultInitializeAtRuntime(
// Creating descriptor/passing null descriptor to the runtime would
// create runtime crashes.
auto isPresent = fir::IsPresentOp::create(builder, loc, builder.getI1Type(),
- fir::getBase(exv));
+ fir::getBase(exv));
builder.genIfThen(loc, isPresent)
.genThen([&]() {
auto box = builder.createBox(loc, exv);
@@ -995,9 +994,9 @@ void Fortran::lower::defaultInitializeAtRuntime(
});
}
auto addrOf = fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
fir::CopyOp::create(builder, loc, addrOf, fir::getBase(exv),
- /*noOverlap=*/true);
+ /*noOverlap=*/true);
} else {
mlir::Value box = builder.createBox(loc, exv);
fir::runtime::genDerivedTypeInitialize(builder, loc, box);
@@ -1098,7 +1097,7 @@ static void finalizeAtRuntime(Fortran::lower::AbstractConverter &converter,
if (Fortran::semantics::IsOptional(sym)) {
// Only finalize if present.
auto isPresent = fir::IsPresentOp::create(builder, loc, builder.getI1Type(),
- fir::getBase(exv));
+ fir::getBase(exv));
builder.genIfThen(loc, isPresent)
.genThen([&]() {
auto box = builder.createBox(loc, exv);
@@ -1144,8 +1143,8 @@ static void deallocateIntentOut(Fortran::lower::AbstractConverter &converter,
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
if (Fortran::semantics::IsOptional(sym)) {
- auto isPresent = fir::IsPresentOp::create(builder,
- loc, builder.getI1Type(), fir::getBase(extVal));
+ auto isPresent = fir::IsPresentOp::create(
+ builder, loc, builder.getI1Type(), fir::getBase(extVal));
builder.genIfThen(loc, isPresent)
.genThen([&]() {
Fortran::lower::genDeallocateIfAllocated(converter, *mutBox, loc);
@@ -1419,7 +1418,7 @@ instantiateAggregateStore(Fortran::lower::AbstractConverter &converter,
defineGlobalAggregateStore(converter, aggregate, aggName, linkage);
}
auto addr = fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
auto size = std::get<1>(var.getInterval());
fir::SequenceType::Shape shape(1, size);
auto seqTy = fir::SequenceType::get(shape, i8Ty);
@@ -1466,8 +1465,8 @@ static void instantiateAlias(Fortran::lower::AbstractConverter &converter,
std::size_t off = sym.GetUltimate().offset() - var.getAliasOffset();
mlir::Value storeAddr = getAggregateStore(storeMap, var);
mlir::Value offset = builder.createIntegerConstant(loc, idxTy, off);
- mlir::Value bytePtr = fir::CoordinateOp::create(builder,
- loc, i8Ptr, storeAddr, mlir::ValueRange{offset});
+ mlir::Value bytePtr = fir::CoordinateOp::create(
+ builder, loc, i8Ptr, storeAddr, mlir::ValueRange{offset});
mlir::Value typedPtr = castAliasToPointer(builder, loc, symType, bytePtr);
Fortran::lower::StatementContext stmtCtx;
mapSymbolAttributes(converter, var, symMap, stmtCtx, typedPtr);
@@ -1681,7 +1680,7 @@ static void finalizeCommonBlockDefinition(
mlir::Value castVal = builder.createConvert(
loc, commonTy.getType(tupIdx), fir::getBase(initVal));
cb = fir::InsertValueOp::create(builder, loc, commonTy, cb, castVal,
- builder.getArrayAttr(offVal));
+ builder.getArrayAttr(offVal));
++tupIdx;
offset = mem->offset() + mem->size();
}
@@ -1722,8 +1721,8 @@ mlir::Value Fortran::lower::genCommonBlockMember(
mlir::Value offs =
builder.createIntegerConstant(loc, builder.getIndexType(), byteOffset);
- mlir::Value varAddr = fir::CoordinateOp::create(builder,
- loc, i8Ptr, base, mlir::ValueRange{offs});
+ mlir::Value varAddr = fir::CoordinateOp::create(builder, loc, i8Ptr, base,
+ mlir::ValueRange{offs});
mlir::Type symType = converter.genType(sym);
return Fortran::semantics::FindEquivalenceSet(sym) != nullptr
@@ -1749,7 +1748,7 @@ static void instantiateCommon(Fortran::lower::AbstractConverter &converter,
// introduce a local AddrOf and add it to the map
fir::GlobalOp global = getCommonBlockGlobal(converter, common);
commonAddr = fir::AddrOfOp::create(builder, loc, global.resultType(),
- global.getSymbol());
+ global.getSymbol());
symMap.addSymbol(common, commonAddr);
}
@@ -2031,8 +2030,8 @@ static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
Fortran::semantics::GetCUDADataAttr(&sym.GetUltimate()));
// Declare a local pointer variable.
- auto newBase = hlfir::DeclareOp::create(builder,
- loc, boxAlloc, name, /*shape=*/nullptr, lenParams,
+ auto newBase = hlfir::DeclareOp::create(
+ builder, loc, boxAlloc, name, /*shape=*/nullptr, lenParams,
/*dummy_scope=*/nullptr, attributes);
mlir::Value nullAddr = builder.createNullConstant(
loc, llvm::cast<fir::BaseBoxType>(ptrBoxType).getEleTy());
@@ -2048,7 +2047,7 @@ static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
// declaration.
mlir::Value initVal =
fir::EmboxOp::create(builder, loc, ptrBoxType, nullAddr, shapeOrShift,
- /*slice=*/nullptr, lenParams);
+ /*slice=*/nullptr, lenParams);
fir::StoreOp::create(builder, loc, initVal, newBase.getBase());
// Any reference to the pointee is going to be using the pointer
@@ -2063,9 +2062,9 @@ static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
mlir::Value dummyScope;
if (converter.isRegisteredDummySymbol(sym))
dummyScope = converter.dummyArgsScopeValue();
- auto newBase = hlfir::DeclareOp::create(builder,
- loc, base, name, shapeOrShift, lenParams, dummyScope, attributes,
- dataAttr);
+ auto newBase =
+ hlfir::DeclareOp::create(builder, loc, base, name, shapeOrShift,
+ lenParams, dummyScope, attributes, dataAttr);
symMap.addVariableDefinition(sym, newBase, force);
return;
}
@@ -2304,8 +2303,8 @@ void Fortran::lower::mapSymbolAttributes(
mlir::Type lenType = builder.getCharacterLengthType();
mlir::Value addr, len;
if (Fortran::semantics::IsOptional(sym)) {
- auto isPresent = fir::IsPresentOp::create(builder,
- loc, builder.getI1Type(), dummyArg);
+ auto isPresent = fir::IsPresentOp::create(
+ builder, loc, builder.getI1Type(), dummyArg);
auto addrAndLen =
builder
.genIfOp(loc, {refTy, lenType}, isPresent,
@@ -2315,15 +2314,15 @@ void Fortran::lower::mapSymbolAttributes(
fir::BoxAddrOp::create(builder, loc, refTy, dummyArg);
mlir::Value readLength =
charHelp.readLengthFromBox(dummyArg);
- fir::ResultOp::create(builder,
- loc, mlir::ValueRange{readAddr, readLength});
+ fir::ResultOp::create(
+ builder, loc, mlir::ValueRange{readAddr, readLength});
})
.genElse([&] {
mlir::Value readAddr = builder.genAbsentOp(loc, refTy);
mlir::Value readLength =
fir::factory::createZeroValue(builder, loc, lenType);
- fir::ResultOp::create(builder,
- loc, mlir::ValueRange{readAddr, readLength});
+ fir::ResultOp::create(
+ builder, loc, mlir::ValueRange{readAddr, readLength});
})
.getResults();
addr = addrAndLen[0];
@@ -2803,8 +2802,8 @@ Fortran::lower::genPackArray(Fortran::lower::AbstractConverter &converter,
mlir::Type elementType = boxType.unwrapInnerType();
llvm::SmallVector<mlir::Value> elidedLenParams =
fir::factory::elideLengthsAlreadyInType(elementType, lenParams);
- auto packOp = fir::PackArrayOp::create(builder,
- loc, fir::getBase(exv), stackAlloc, isInnermostMode, noCopy,
+ auto packOp = fir::PackArrayOp::create(
+ builder, loc, fir::getBase(exv), stackAlloc, isInnermostMode, noCopy,
/*max_size=*/mlir::IntegerAttr{},
/*max_element_size=*/mlir::IntegerAttr{},
/*min_stride=*/mlir::IntegerAttr{}, fir::PackArrayHeuristics::None,
@@ -2843,5 +2842,5 @@ void Fortran::lower::genUnpackArray(
bool noCopy = Fortran::semantics::IsIntentIn(sym);
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
fir::UnpackArrayOp::create(builder, loc, temp, original, stackAlloc, noCopy,
- getSafeRepackAttrs(converter));
+ getSafeRepackAttrs(converter));
}
diff --git a/flang/lib/Lower/CustomIntrinsicCall.cpp b/flang/lib/Lower/CustomIntrinsicCall.cpp
index 5040989b1..2c5233bdd 100644
--- a/flang/lib/Lower/CustomIntrinsicCall.cpp
+++ b/flang/lib/Lower/CustomIntrinsicCall.cpp
@@ -296,7 +296,8 @@ lowerAssociated(fir::FirOpBuilder &builder, mlir::Location loc,
fir::ResultOp::create(builder, loc, cast);
})
.genElse([&]() {
- mlir::Value absentBox = fir::AbsentOp::create(builder, loc, boxType);
+ mlir::Value absentBox =
+ fir::AbsentOp::create(builder, loc, boxType);
fir::ResultOp::create(builder, loc, absentBox);
})
.getResults()[0];
diff --git a/flang/lib/Lower/HlfirIntrinsics.cpp b/flang/lib/Lower/HlfirIntrinsics.cpp
index 116742b7c..6e1d06a25 100644
--- a/flang/lib/Lower/HlfirIntrinsics.cpp
+++ b/flang/lib/Lower/HlfirIntrinsics.cpp
@@ -210,8 +210,8 @@ mlir::Value HlfirTransformationalIntrinsic::loadBoxAddress(
mlir::Value box = builder.createBox(loc, exv);
mlir::Type boxType = box.getType();
auto absent = fir::AbsentOp::create(builder, loc, boxType);
- auto boxOrAbsent = mlir::arith::SelectOp::create(builder,
- loc, boxType, isPresent, box, absent);
+ auto boxOrAbsent = mlir::arith::SelectOp::create(builder, loc, boxType,
+ isPresent, box, absent);
return boxOrAbsent;
}
diff --git a/flang/lib/Lower/HostAssociations.cpp b/flang/lib/Lower/HostAssociations.cpp
index aeaa6e27b..2a330ccc4 100644
--- a/flang/lib/Lower/HostAssociations.cpp
+++ b/flang/lib/Lower/HostAssociations.cpp
@@ -300,8 +300,8 @@ public:
auto addr = fir::BoxAddrOp::create(builder, loc, eleTy, box);
mlir::Value isPresent = builder.genIsNotNullAddr(loc, addr);
auto absentBox = fir::AbsentOp::create(builder, loc, boxTy);
- box =
- mlir::arith::SelectOp::create(builder, loc, isPresent, box, absentBox);
+ box = mlir::arith::SelectOp::create(builder, loc, isPresent, box,
+ absentBox);
}
bindCapturedSymbol(sym, box, converter, args.symMap);
}
@@ -404,8 +404,8 @@ public:
// done on present optional. For absent optionals, simply create a
// disassociated pointer (it is illegal to inquire about lower bounds or
// lengths of optional according to 15.5.2.12 3 (9) and 10.1.11 2 (7)b).
- auto isPresent = fir::IsPresentOp::create(builder,
- loc, builder.getI1Type(), fir::getBase(args.hostValue));
+ auto isPresent = fir::IsPresentOp::create(
+ builder, loc, builder.getI1Type(), fir::getBase(args.hostValue));
builder.genIfThenElse(loc, isPresent)
.genThen([&]() {
fir::factory::associateMutableBox(builder, loc, boxInTuple,
@@ -442,7 +442,7 @@ public:
for (unsigned dim = 0; dim < rank; ++dim) {
mlir::Value dimVal = builder.createIntegerConstant(loc, idxTy, dim);
auto dims = fir::BoxDimsOp::create(builder, loc, idxTy, idxTy, idxTy,
- box, dimVal);
+ box, dimVal);
lbounds.emplace_back(dims.getResult(0));
}
}
@@ -468,7 +468,7 @@ public:
mlir::Value isPresent = builder.genIsNotNullAddr(loc, addr);
auto absentBox = fir::AbsentOp::create(builder, loc, boxTy);
box = mlir::arith::SelectOp::create(builder, loc, isPresent, box,
- absentBox);
+ absentBox);
}
fir::BoxValue boxValue(box, lbounds, /*explicitParams=*/{});
bindCapturedSymbol(sym, boxValue, converter, args.symMap);
diff --git a/flang/lib/Lower/IO.cpp b/flang/lib/Lower/IO.cpp
index 32ddd0ea9..c95c3404a 100644
--- a/flang/lib/Lower/IO.cpp
+++ b/flang/lib/Lower/IO.cpp
@@ -153,8 +153,8 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
if (csi.ioMsg) {
mlir::func::FuncOp getIoMsg =
fir::runtime::getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
- fir::CallOp::create(builder,
- loc, getIoMsg,
+ fir::CallOp::create(
+ builder, loc, getIoMsg,
mlir::ValueRange{
cookie,
builder.createConvert(loc, getIoMsg.getFunctionType().getInput(1),
@@ -165,7 +165,7 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
mlir::func::FuncOp endIoStatement =
fir::runtime::getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
auto call = fir::CallOp::create(builder, loc, endIoStatement,
- mlir::ValueRange{cookie});
+ mlir::ValueRange{cookie});
mlir::Value iostat = call.getResult(0);
if (csi.bigUnitIfOp) {
stmtCtx.finalizeAndPop();
@@ -204,7 +204,7 @@ static void makeNextConditionalOn(fir::FirOpBuilder &builder,
if (inLoop)
resTy = boolTy;
auto ifOp = fir::IfOp::create(builder, loc, resTy, ok,
- /*withElseRegion=*/inLoop);
+ /*withElseRegion=*/inLoop);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
}
@@ -259,10 +259,10 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
? fir::NameUniquer::doGenerated("default" + suffix)
: converter.mangleName(suffix);
if (auto table = builder.getNamedGlobal(tableMangleName))
- return builder.createConvert(
- loc, refTy,
- fir::AddrOfOp::create(builder, loc, table.resultType(),
- table.getSymbol()));
+ return builder.createConvert(loc, refTy,
+ fir::AddrOfOp::create(builder, loc,
+ table.resultType(),
+ table.getSymbol()));
mlir::StringAttr linkOnce = builder.createLinkOnceLinkage();
mlir::Type idxTy = builder.getIndexType();
@@ -281,8 +281,9 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
// Define the list of NonTbpDefinedIo procedures.
bool tableIsLocal =
!definedIoProcMap.empty() && hasLocalDefinedIoProc(definedIoProcMap);
- mlir::Value listAddr =
- tableIsLocal ? fir::AllocaOp::create(builder, loc, listTy) : mlir::Value{};
+ mlir::Value listAddr = tableIsLocal
+ ? fir::AllocaOp::create(builder, loc, listTy)
+ : mlir::Value{};
std::string listMangleName = tableMangleName + ".list";
auto listFunc = [&](fir::FirOpBuilder &builder) {
mlir::Value list = fir::UndefOp::create(builder, loc, listTy);
@@ -295,7 +296,7 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
auto insert = [&](mlir::Value val) {
idx[1] = intAttr[n1++];
list = fir::InsertValueOp::create(builder, loc, listTy, list, val,
- builder.getArrayAttr(idx));
+ builder.getArrayAttr(idx));
};
for (auto &iface : definedIoProcMap) {
idx[0] = builder.getIntegerAttr(idxTy, n0++);
@@ -305,8 +306,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
std::string dtName = converter.mangleName(dtSym);
insert(builder.createConvert(
loc, refTy,
- fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(converter.genType(dtSym)),
+ fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(converter.genType(dtSym)),
builder.getSymbolRefAttr(dtName))));
// defined IO procedure [void (*subroutine)()], may be null
const Fortran::semantics::Symbol *procSym = iface.second.subroutine;
@@ -316,8 +317,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
TODO(loc, "defined IO procedure pointers");
} else if (Fortran::semantics::IsDummy(*procSym)) {
Fortran::lower::StatementContext stmtCtx;
- insert(fir::BoxAddrOp::create(builder,
- loc, refTy,
+ insert(fir::BoxAddrOp::create(
+ builder, loc, refTy,
fir::getBase(converter.genExprAddr(
loc,
Fortran::lower::SomeExpr{
@@ -331,7 +332,7 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
insert(builder.createConvert(
loc, refTy,
fir::AddrOfOp::create(builder, loc, procDef.getFunctionType(),
- nameAttr)));
+ nameAttr)));
}
} else {
insert(builder.createNullConstant(loc, refTy));
@@ -365,8 +366,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
auto tableFunc = [&](fir::FirOpBuilder &builder) {
mlir::Value table = fir::UndefOp::create(builder, loc, tableTy);
// list item count [std::size_t items]
- table = fir::InsertValueOp::create(builder,
- loc, tableTy, table,
+ table = fir::InsertValueOp::create(
+ builder, loc, tableTy, table,
builder.createIntegerConstant(loc, sizeTy, definedIoProcMap.size()),
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 0)));
// item list [const NonTbpDefinedIo *item]
@@ -374,14 +375,15 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
listAddr = builder.createNullConstant(loc, builder.getRefType(listTy));
else if (fir::GlobalOp list = builder.getNamedGlobal(listMangleName))
listAddr = fir::AddrOfOp::create(builder, loc, list.resultType(),
- list.getSymbol());
+ list.getSymbol());
assert(listAddr && "missing namelist object list");
- table = fir::InsertValueOp::create(builder,
- loc, tableTy, table, listAddr,
+ table = fir::InsertValueOp::create(
+ builder, loc, tableTy, table, listAddr,
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 1)));
// [bool ignoreNonTbpEntries] conservatively set to true
- table = fir::InsertValueOp::create(builder,
- loc, tableTy, table, builder.createIntegerConstant(loc, boolTy, true),
+ table = fir::InsertValueOp::create(
+ builder, loc, tableTy, table,
+ builder.createIntegerConstant(loc, boolTy, true),
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 2)));
if (tableIsLocal)
fir::StoreOp::create(builder, loc, table, tableAddr);
@@ -394,8 +396,8 @@ getNonTbpDefinedIoTableAddr(Fortran::lower::AbstractConverter &converter,
fir::GlobalOp table = builder.createGlobal(
loc, tableTy, tableMangleName,
/*isConst=*/true, /*isTarget=*/false, tableFunc, linkOnce);
- tableAddr = fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(tableTy), table.getSymbol());
+ tableAddr = fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(tableTy), table.getSymbol());
}
assert(tableAddr && "missing NonTbpDefinedIo table result");
return builder.createConvert(loc, refTy, tableAddr);
@@ -421,7 +423,7 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
std::string groupMangleName = converter.mangleName(symbol);
if (auto group = builder.getNamedGlobal(groupMangleName))
return fir::AddrOfOp::create(builder, loc, group.resultType(),
- group.getSymbol());
+ group.getSymbol());
const auto &details =
symbol.GetUltimate().get<Fortran::semantics::NamelistDetails>();
@@ -475,8 +477,9 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
}
// Define the list of Items.
- mlir::Value listAddr =
- groupIsLocal ? fir::AllocaOp::create(builder, loc, listTy) : mlir::Value{};
+ mlir::Value listAddr = groupIsLocal
+ ? fir::AllocaOp::create(builder, loc, listTy)
+ : mlir::Value{};
std::string listMangleName = groupMangleName + ".list";
auto listFunc = [&](fir::FirOpBuilder &builder) {
mlir::Value list = fir::UndefOp::create(builder, loc, listTy);
@@ -491,13 +494,13 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
mlir::Value nameAddr =
builder.createConvert(loc, charRefTy, fir::getBase(stringAddress(s)));
list = fir::InsertValueOp::create(builder, loc, listTy, list, nameAddr,
- builder.getArrayAttr(idx));
+ builder.getArrayAttr(idx));
idx[1] = one;
mlir::Value descAddr;
if (auto desc = builder.getNamedGlobal(
Fortran::lower::mangle::globalNamelistDescriptorName(s))) {
descAddr = fir::AddrOfOp::create(builder, loc, desc.resultType(),
- desc.getSymbol());
+ desc.getSymbol());
} else if (Fortran::semantics::FindCommonBlockContaining(s) &&
IsAllocatableOrPointer(s)) {
mlir::Type symType = converter.genType(s);
@@ -505,8 +508,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
Fortran::semantics::FindCommonBlockContaining(s);
std::string commonBlockName = converter.mangleName(*commonBlockSym);
fir::GlobalOp commonGlobal = builder.getNamedGlobal(commonBlockName);
- mlir::Value commonBlockAddr = fir::AddrOfOp::create(builder,
- loc, commonGlobal.resultType(), commonGlobal.getSymbol());
+ mlir::Value commonBlockAddr = fir::AddrOfOp::create(
+ builder, loc, commonGlobal.resultType(), commonGlobal.getSymbol());
mlir::IntegerType i8Ty = builder.getIntegerType(8);
mlir::Type i8Ptr = builder.getRefType(i8Ty);
mlir::Type seqTy = builder.getRefType(builder.getVarLenSeqTy(i8Ty));
@@ -514,8 +517,8 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
std::size_t byteOffset = s.GetUltimate().offset();
mlir::Value offs = builder.createIntegerConstant(
loc, builder.getIndexType(), byteOffset);
- mlir::Value varAddr = fir::CoordinateOp::create(builder,
- loc, i8Ptr, base, mlir::ValueRange{offs});
+ mlir::Value varAddr = fir::CoordinateOp::create(
+ builder, loc, i8Ptr, base, mlir::ValueRange{offs});
descAddr =
builder.createConvert(loc, builder.getRefType(symType), varAddr);
} else {
@@ -532,7 +535,7 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
}
descAddr = builder.createConvert(loc, descRefTy, descAddr);
list = fir::InsertValueOp::create(builder, loc, listTy, list, descAddr,
- builder.getArrayAttr(idx));
+ builder.getArrayAttr(idx));
}
if (groupIsLocal)
fir::StoreOp::create(builder, loc, list, listAddr);
@@ -552,28 +555,28 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
auto groupFunc = [&](fir::FirOpBuilder &builder) {
mlir::Value group = fir::UndefOp::create(builder, loc, groupTy);
// group name [const char *groupName]
- group = fir::InsertValueOp::create(builder,
- loc, groupTy, group,
+ group = fir::InsertValueOp::create(
+ builder, loc, groupTy, group,
builder.createConvert(loc, charRefTy,
fir::getBase(stringAddress(symbol))),
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 0)));
// list item count [std::size_t items]
- group = fir::InsertValueOp::create(builder,
- loc, groupTy, group,
+ group = fir::InsertValueOp::create(
+ builder, loc, groupTy, group,
builder.createIntegerConstant(loc, sizeTy, details.objects().size()),
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 1)));
// item list [const Item *item]
if (fir::GlobalOp list = builder.getNamedGlobal(listMangleName))
listAddr = fir::AddrOfOp::create(builder, loc, list.resultType(),
- list.getSymbol());
+ list.getSymbol());
assert(listAddr && "missing namelist object list");
- group = fir::InsertValueOp::create(builder,
- loc, groupTy, group, listAddr,
+ group = fir::InsertValueOp::create(
+ builder, loc, groupTy, group, listAddr,
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 2)));
// non-type-bound defined IO procedures
// [const NonTbpDefinedIoTable *nonTbpDefinedIo]
- group = fir::InsertValueOp::create(builder,
- loc, groupTy, group,
+ group = fir::InsertValueOp::create(
+ builder, loc, groupTy, group,
getNonTbpDefinedIoTableAddr(converter, definedIoProcMap),
builder.getArrayAttr(builder.getIntegerAttr(idxTy, 3)));
if (groupIsLocal)
@@ -588,7 +591,7 @@ getNamelistGroup(Fortran::lower::AbstractConverter &converter,
loc, groupTy, groupMangleName,
/*isConst=*/true, /*isTarget=*/false, groupFunc, linkOnce);
groupAddr = fir::AddrOfOp::create(builder, loc, group.resultType(),
- group.getSymbol());
+ group.getSymbol());
}
assert(groupAddr && "missing namelist group result");
return groupAddr;
@@ -849,9 +852,10 @@ createIoRuntimeCallForItem(Fortran::lower::AbstractConverter &converter,
inputFuncArgs.push_back(builder.createConvert(
loc, inputFunc.getFunctionType().getInput(2), len));
} else if (mlir::isa<mlir::IntegerType>(itemTy)) {
- inputFuncArgs.push_back(mlir::arith::ConstantOp::create(builder,
- loc, builder.getI32IntegerAttr(
- mlir::cast<mlir::IntegerType>(itemTy).getWidth() / 8)));
+ inputFuncArgs.push_back(mlir::arith::ConstantOp::create(
+ builder, loc,
+ builder.getI32IntegerAttr(
+ mlir::cast<mlir::IntegerType>(itemTy).getWidth() / 8)));
}
}
auto call = fir::CallOp::create(builder, loc, inputFunc, inputFuncArgs);
@@ -962,17 +966,17 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter,
};
if (!checkResult) {
// No IO call result checks - the loop is a fir.do_loop op.
- auto doLoopOp = fir::DoLoopOp::create(builder,
- loc, lowerValue, upperValue, stepValue, /*unordered=*/false,
- /*finalCountValue=*/true);
+ auto doLoopOp = fir::DoLoopOp::create(builder, loc, lowerValue, upperValue,
+ stepValue, /*unordered=*/false,
+ /*finalCountValue=*/true);
builder.setInsertionPointToStart(doLoopOp.getBody());
mlir::Value lcv = builder.createConvert(
loc, fir::unwrapRefType(loopVar.getType()), doLoopOp.getInductionVar());
fir::StoreOp::create(builder, loc, lcv, loopVar);
genItemList(ioImpliedDo);
builder.setInsertionPointToEnd(doLoopOp.getBody());
- mlir::Value result = mlir::arith::AddIOp::create(builder,
- loc, doLoopOp.getInductionVar(), doLoopOp.getStep(), iofAttr);
+ mlir::Value result = mlir::arith::AddIOp::create(
+ builder, loc, doLoopOp.getInductionVar(), doLoopOp.getStep(), iofAttr);
fir::ResultOp::create(builder, loc, result);
builder.setInsertionPointAfter(doLoopOp);
// The loop control variable may be used after the loop.
@@ -984,8 +988,9 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter,
// Check IO call results - the loop is a fir.iterate_while op.
if (!ok)
ok = builder.createBool(loc, true);
- auto iterWhileOp = fir::IterWhileOp::create(builder,
- loc, lowerValue, upperValue, stepValue, ok, /*finalCountValue*/ true);
+ auto iterWhileOp =
+ fir::IterWhileOp::create(builder, loc, lowerValue, upperValue, stepValue,
+ ok, /*finalCountValue*/ true);
builder.setInsertionPointToStart(iterWhileOp.getBody());
mlir::Value lcv =
builder.createConvert(loc, fir::unwrapRefType(loopVar.getType()),
@@ -1013,10 +1018,10 @@ static void genIoLoop(Fortran::lower::AbstractConverter &converter,
builder.setInsertionPointToEnd(iterWhileOp.getBody());
mlir::OpResult iterateResult = builder.getBlock()->back().getResult(0);
mlir::Value inductionResult0 = iterWhileOp.getInductionVar();
- auto inductionResult1 = mlir::arith::AddIOp::create(builder,
- loc, inductionResult0, iterWhileOp.getStep(), iofAttr);
- auto inductionResult = mlir::arith::SelectOp::create(builder,
- loc, iterateResult, inductionResult1, inductionResult0);
+ auto inductionResult1 = mlir::arith::AddIOp::create(
+ builder, loc, inductionResult0, iterWhileOp.getStep(), iofAttr);
+ auto inductionResult = mlir::arith::SelectOp::create(
+ builder, loc, iterateResult, inductionResult1, inductionResult0);
llvm::SmallVector<mlir::Value> results = {inductionResult, iterateResult};
fir::ResultOp::create(builder, loc, results);
ok = iterWhileOp.getResult(1);
@@ -1046,15 +1051,15 @@ static mlir::Value locToLineNo(Fortran::lower::AbstractConverter &converter,
static mlir::Value getDefaultScratch(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Type toType) {
- mlir::Value null = mlir::arith::ConstantOp::create(builder,
- loc, builder.getI64IntegerAttr(0));
+ mlir::Value null = mlir::arith::ConstantOp::create(
+ builder, loc, builder.getI64IntegerAttr(0));
return builder.createConvert(loc, toType, null);
}
static mlir::Value getDefaultScratchLen(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Type toType) {
- return mlir::arith::ConstantOp::create(builder,
- loc, builder.getIntegerAttr(toType, 0));
+ return mlir::arith::ConstantOp::create(builder, loc,
+ builder.getIntegerAttr(toType, 0));
}
/// Generate a reference to a buffer and the length of buffer given
@@ -1105,8 +1110,8 @@ lowerStringLit(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
mlir::Value kind;
if (ty2) {
auto kindVal = expr->GetType().value().kind();
- kind = mlir::arith::ConstantOp::create(builder,
- loc, builder.getIntegerAttr(ty2, kindVal));
+ kind = mlir::arith::ConstantOp::create(
+ builder, loc, builder.getIntegerAttr(ty2, kindVal));
}
return {buff, len, kind};
}
@@ -1480,8 +1485,8 @@ genConditionHandlerCall(Fortran::lower::AbstractConverter &converter,
fir::runtime::getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
mlir::Type boolType = enableHandlers.getFunctionType().getInput(1);
auto boolValue = [&](bool specifierIsPresent) {
- return mlir::arith::ConstantOp::create(builder,
- loc, builder.getIntegerAttr(boolType, specifierIsPresent));
+ return mlir::arith::ConstantOp::create(
+ builder, loc, builder.getIntegerAttr(boolType, specifierIsPresent));
};
llvm::SmallVector<mlir::Value> ioArgs = {cookie,
boolValue(csi.ioStatExpr != nullptr),
@@ -1819,10 +1824,10 @@ static mlir::Value genIOUnitNumber(Fortran::lower::AbstractConverter &converter,
mlir::Value iostat = checkCall.getResult(0);
mlir::Type iostatTy = iostat.getType();
mlir::Value zero = fir::factory::createZeroValue(builder, loc, iostatTy);
- mlir::Value unitIsOK = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::eq, iostat, zero);
+ mlir::Value unitIsOK = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::eq, iostat, zero);
auto ifOp = fir::IfOp::create(builder, loc, iostatTy, unitIsOK,
- /*withElseRegion=*/true);
+ /*withElseRegion=*/true);
builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
fir::ResultOp::create(builder, loc, iostat);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
@@ -1846,8 +1851,8 @@ static mlir::Value genIOUnit(Fortran::lower::AbstractConverter &converter,
&iounit->u))
return genIOUnitNumber(converter, loc, Fortran::semantics::GetExpr(*e),
ty, csi, stmtCtx);
- return mlir::arith::ConstantOp::create(builder,
- loc, builder.getIntegerAttr(ty, defaultUnitNumber));
+ return mlir::arith::ConstantOp::create(
+ builder, loc, builder.getIntegerAttr(ty, defaultUnitNumber));
}
template <typename A>
@@ -1880,7 +1885,7 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
mlir::Value file = locToFilename(converter, loc, beginFuncTy.getInput(1));
mlir::Value line = locToLineNo(converter, loc, beginFuncTy.getInput(2));
auto call = fir::CallOp::create(builder, loc, beginFunc,
- mlir::ValueRange{un, file, line});
+ mlir::ValueRange{un, file, line});
mlir::Value cookie = call.getResult(0);
genConditionHandlerCall(converter, loc, cookie, stmt.v, csi);
mlir::Value ok;
@@ -2149,9 +2154,10 @@ void genBeginDataTransferCallArgs(
}
} else { // PRINT - maybe explicit format; default unit
maybeGetFormatArgs();
- ioArgs.push_back(mlir::arith::ConstantOp::create(builder,
- loc, builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()),
- defaultUnitNumber)));
+ ioArgs.push_back(mlir::arith::ConstantOp::create(
+ builder, loc,
+ builder.getIntegerAttr(ioFuncTy.getInput(ioArgs.size()),
+ defaultUnitNumber)));
}
// File name and line number are always the last two arguments.
ioArgs.push_back(
diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp
index 13b2d5155..471f36859 100644
--- a/flang/lib/Lower/OpenACC.cpp
+++ b/flang/lib/Lower/OpenACC.cpp
@@ -264,8 +264,8 @@ static void createDeclareAllocFuncWithArg(mlir::OpBuilder &modBuilder,
builder, loc, boxAddrOp.getResult(), asFortran, bounds,
/*structured=*/false, /*implicit=*/false, clause, boxAddrOp.getType(),
/*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
- mlir::acc::DeclareEnterOp::create(builder,
- loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()),
+ mlir::acc::DeclareEnterOp::create(
+ builder, loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()),
mlir::ValueRange(entryOp.getAccVar()));
}
@@ -303,25 +303,25 @@ static void createDeclareDeallocFuncWithArg(
builder, loc, var, asFortran, bounds,
/*structured=*/false, /*implicit=*/false, clause, var.getType(),
/*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
- mlir::acc::DeclareExitOp::create(builder,
- loc, mlir::Value{}, mlir::ValueRange(entryOp.getAccVar()));
+ mlir::acc::DeclareExitOp::create(builder, loc, mlir::Value{},
+ mlir::ValueRange(entryOp.getAccVar()));
if constexpr (std::is_same_v<ExitOp, mlir::acc::CopyoutOp> ||
std::is_same_v<ExitOp, mlir::acc::UpdateHostOp>)
ExitOp::create(builder, entryOp.getLoc(), entryOp.getAccVar(),
- entryOp.getVar(), entryOp.getVarType(),
- entryOp.getBounds(), entryOp.getAsyncOperands(),
- entryOp.getAsyncOperandsDeviceTypeAttr(),
- entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
- /*structured=*/false, /*implicit=*/false,
- builder.getStringAttr(*entryOp.getName()));
+ entryOp.getVar(), entryOp.getVarType(), entryOp.getBounds(),
+ entryOp.getAsyncOperands(),
+ entryOp.getAsyncOperandsDeviceTypeAttr(),
+ entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
+ /*structured=*/false, /*implicit=*/false,
+ builder.getStringAttr(*entryOp.getName()));
else
ExitOp::create(builder, entryOp.getLoc(), entryOp.getAccVar(),
- entryOp.getBounds(), entryOp.getAsyncOperands(),
- entryOp.getAsyncOperandsDeviceTypeAttr(),
- entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
- /*structured=*/false, /*implicit=*/false,
- builder.getStringAttr(*entryOp.getName()));
+ entryOp.getBounds(), entryOp.getAsyncOperands(),
+ entryOp.getAsyncOperandsDeviceTypeAttr(),
+ entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
+ /*structured=*/false, /*implicit=*/false,
+ builder.getStringAttr(*entryOp.getName()));
// Generate the post dealloc function.
modBuilder.setInsertionPointAfter(preDeallocOp);
@@ -385,8 +385,8 @@ genAtomicCaptureStatement(Fortran::lower::AbstractConverter &converter,
// Generate `atomic.read` operation for atomic assigment statements
fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
- mlir::acc::AtomicReadOp::create(firOpBuilder,
- loc, fromAddress, toAddress, mlir::TypeAttr::get(elementType));
+ mlir::acc::AtomicReadOp::create(firOpBuilder, loc, fromAddress, toAddress,
+ mlir::TypeAttr::get(elementType));
}
/// Used to generate atomic.write operation which is created in existing
@@ -839,15 +839,15 @@ genDataExitOperations(fir::FirOpBuilder &builder,
mlir::Location opLoc = exitLoc ? *exitLoc : entryOp.getLoc();
if constexpr (std::is_same_v<ExitOp, mlir::acc::CopyoutOp> ||
std::is_same_v<ExitOp, mlir::acc::UpdateHostOp>)
- ExitOp::create(builder,
- opLoc, entryOp.getAccVar(), entryOp.getVar(), entryOp.getVarType(),
- entryOp.getBounds(), entryOp.getAsyncOperands(),
+ ExitOp::create(
+ builder, opLoc, entryOp.getAccVar(), entryOp.getVar(),
+ entryOp.getVarType(), entryOp.getBounds(), entryOp.getAsyncOperands(),
entryOp.getAsyncOperandsDeviceTypeAttr(), entryOp.getAsyncOnlyAttr(),
entryOp.getDataClause(), structured, entryOp.getImplicit(),
builder.getStringAttr(*entryOp.getName()));
else
- ExitOp::create(builder,
- opLoc, entryOp.getAccVar(), entryOp.getBounds(),
+ ExitOp::create(
+ builder, opLoc, entryOp.getAccVar(), entryOp.getBounds(),
entryOp.getAsyncOperands(), entryOp.getAsyncOperandsDeviceTypeAttr(),
entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(), structured,
entryOp.getImplicit(), builder.getStringAttr(*entryOp.getName()));
@@ -859,8 +859,8 @@ fir::ShapeOp genShapeOp(mlir::OpBuilder &builder, fir::SequenceType seqTy,
llvm::SmallVector<mlir::Value> extents;
mlir::Type idxTy = builder.getIndexType();
for (auto extent : seqTy.getShape())
- extents.push_back(mlir::arith::ConstantOp::create(builder,
- loc, idxTy, builder.getIntegerAttr(idxTy, extent)));
+ extents.push_back(mlir::arith::ConstantOp::create(
+ builder, loc, idxTy, builder.getIntegerAttr(idxTy, extent)));
return fir::ShapeOp::create(builder, loc, extents);
}
@@ -936,8 +936,8 @@ static mlir::Value getReductionInitValue(fir::FirOpBuilder &builder,
return builder.createBool(loc, value);
}
if (ty.isIntOrIndex())
- return mlir::arith::ConstantOp::create(builder,
- loc, ty,
+ return mlir::arith::ConstantOp::create(
+ builder, loc, ty,
builder.getIntegerAttr(ty, getReductionInitValue<llvm::APInt>(op, ty)));
if (op == mlir::acc::ReductionOperator::AccMin ||
op == mlir::acc::ReductionOperator::AccMax) {
@@ -945,13 +945,13 @@ static mlir::Value getReductionInitValue(fir::FirOpBuilder &builder,
llvm::report_fatal_error(
"min/max reduction not supported for complex type");
if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty))
- return mlir::arith::ConstantOp::create(builder,
- loc, ty,
+ return mlir::arith::ConstantOp::create(
+ builder, loc, ty,
builder.getFloatAttr(ty,
getReductionInitValue<llvm::APFloat>(op, ty)));
} else if (auto floatTy = mlir::dyn_cast_or_null<mlir::FloatType>(ty)) {
- return mlir::arith::ConstantOp::create(builder,
- loc, ty,
+ return mlir::arith::ConstantOp::create(
+ builder, loc, ty,
builder.getFloatAttr(ty, getReductionInitValue<int64_t>(op, ty)));
} else if (auto cmplxTy = mlir::dyn_cast_or_null<mlir::ComplexType>(ty)) {
mlir::Type floatTy = cmplxTy.getElementType();
@@ -986,7 +986,7 @@ static RecipeOp genRecipeOp(
RecipeOp recipe;
if constexpr (std::is_same_v<RecipeOp, mlir::acc::ReductionRecipeOp>) {
recipe = mlir::acc::ReductionRecipeOp::create(modBuilder, loc, recipeName,
- ty, op);
+ ty, op);
} else {
recipe = RecipeOp::create(modBuilder, loc, recipeName, ty);
}
@@ -1032,8 +1032,8 @@ static RecipeOp genRecipeOp(
initName,
initBlock->getArguments().take_back(initBlock->getArguments().size() - 1),
initValue);
- mlir::acc::YieldOp::create(builder, loc, retVal ? retVal
- : initBlock->getArgument(0));
+ mlir::acc::YieldOp::create(builder, loc,
+ retVal ? retVal : initBlock->getArgument(0));
return recipe;
}
@@ -1134,10 +1134,12 @@ static mlir::Value genShapeFromBoundsOrArgs(
mlir::Value s1 =
mlir::arith::SubIOp::create(builder, loc, args[i + 1], args[0]);
mlir::Value s2 = mlir::arith::AddIOp::create(builder, loc, s1, one);
- mlir::Value s3 = mlir::arith::DivSIOp::create(builder, loc, s2, args[i + 2]);
- mlir::Value cmp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::sgt, s3, zero);
- mlir::Value ext = mlir::arith::SelectOp::create(builder, loc, cmp, s3, zero);
+ mlir::Value s3 =
+ mlir::arith::DivSIOp::create(builder, loc, s2, args[i + 2]);
+ mlir::Value cmp = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::sgt, s3, zero);
+ mlir::Value ext =
+ mlir::arith::SelectOp::create(builder, loc, cmp, s3, zero);
extents.push_back(ext);
}
return fir::ShapeOp::create(builder, loc, extents);
@@ -1157,8 +1159,8 @@ static hlfir::Entity genDesignateWithTriplets(
hlfir::DesignateOp::Subscripts &triplets, mlir::Value shape) {
llvm::SmallVector<mlir::Value> lenParams;
hlfir::genLengthParameters(loc, builder, entity, lenParams);
- auto designate = hlfir::DesignateOp::create(builder,
- loc, entity.getBase().getType(), entity, /*component=*/"",
+ auto designate = hlfir::DesignateOp::create(
+ builder, loc, entity.getBase().getType(), entity, /*component=*/"",
/*componentShape=*/mlir::Value{}, triplets,
/*substring=*/mlir::ValueRange{}, /*complexPartAttr=*/std::nullopt, shape,
lenParams);
@@ -1198,22 +1200,22 @@ mlir::acc::FirstprivateRecipeOp Fortran::lower::createOrGetFirstprivateRecipe(
builder.setInsertionPointToEnd(&recipe.getCopyRegion().back());
ty = fir::unwrapRefType(ty);
if (fir::isa_trivial(ty)) {
- mlir::Value initValue = fir::LoadOp::create(builder,
- loc, recipe.getCopyRegion().front().getArgument(0));
+ mlir::Value initValue = fir::LoadOp::create(
+ builder, loc, recipe.getCopyRegion().front().getArgument(0));
fir::StoreOp::create(builder, loc, initValue,
- recipe.getCopyRegion().front().getArgument(1));
+ recipe.getCopyRegion().front().getArgument(1));
} else if (auto seqTy = mlir::dyn_cast_or_null<fir::SequenceType>(ty)) {
fir::FirOpBuilder firBuilder{builder, recipe.getOperation()};
auto shape = genShapeFromBoundsOrArgs(
loc, firBuilder, seqTy, bounds, recipe.getCopyRegion().getArguments());
- auto leftDeclOp = hlfir::DeclareOp::create(builder,
- loc, recipe.getCopyRegion().getArgument(0), llvm::StringRef{}, shape,
- llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
+ auto leftDeclOp = hlfir::DeclareOp::create(
+ builder, loc, recipe.getCopyRegion().getArgument(0), llvm::StringRef{},
+ shape, llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
fir::FortranVariableFlagsAttr{});
- auto rightDeclOp = hlfir::DeclareOp::create(builder,
- loc, recipe.getCopyRegion().getArgument(1), llvm::StringRef{}, shape,
- llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
+ auto rightDeclOp = hlfir::DeclareOp::create(
+ builder, loc, recipe.getCopyRegion().getArgument(1), llvm::StringRef{},
+ shape, llvm::ArrayRef<mlir::Value>{}, /*dummy_scope=*/nullptr,
fir::FortranVariableFlagsAttr{});
hlfir::DesignateOp::Subscripts triplets =
@@ -1520,19 +1522,21 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
auto shape =
genShapeFromBoundsOrArgs(loc, builder, seqTy, bounds,
recipe.getCombinerRegion().getArguments());
- auto v1DeclareOp = hlfir::DeclareOp::create(builder,
- loc, value1, llvm::StringRef{}, shape, llvm::ArrayRef<mlir::Value>{},
+ auto v1DeclareOp = hlfir::DeclareOp::create(
+ builder, loc, value1, llvm::StringRef{}, shape,
+ llvm::ArrayRef<mlir::Value>{},
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
- auto v2DeclareOp = hlfir::DeclareOp::create(builder,
- loc, value2, llvm::StringRef{}, shape, llvm::ArrayRef<mlir::Value>{},
+ auto v2DeclareOp = hlfir::DeclareOp::create(
+ builder, loc, value2, llvm::StringRef{}, shape,
+ llvm::ArrayRef<mlir::Value>{},
/*dummy_scope=*/nullptr, fir::FortranVariableFlagsAttr{});
hlfir::DesignateOp::Subscripts triplets = getTripletsFromArgs(recipe);
llvm::SmallVector<mlir::Value> lenParamsLeft;
auto leftEntity = hlfir::Entity{v1DeclareOp.getBase()};
hlfir::genLengthParameters(loc, builder, leftEntity, lenParamsLeft);
- auto leftDesignate = hlfir::DesignateOp::create(builder,
- loc, v1DeclareOp.getBase().getType(), v1DeclareOp.getBase(),
+ auto leftDesignate = hlfir::DesignateOp::create(
+ builder, loc, v1DeclareOp.getBase().getType(), v1DeclareOp.getBase(),
/*component=*/"",
/*componentShape=*/mlir::Value{}, triplets,
/*substring=*/mlir::ValueRange{}, /*complexPartAttr=*/std::nullopt,
@@ -1542,8 +1546,8 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
llvm::SmallVector<mlir::Value> lenParamsRight;
auto rightEntity = hlfir::Entity{v2DeclareOp.getBase()};
hlfir::genLengthParameters(loc, builder, rightEntity, lenParamsLeft);
- auto rightDesignate = hlfir::DesignateOp::create(builder,
- loc, v2DeclareOp.getBase().getType(), v2DeclareOp.getBase(),
+ auto rightDesignate = hlfir::DesignateOp::create(
+ builder, loc, v2DeclareOp.getBase().getType(), v2DeclareOp.getBase(),
/*component=*/"",
/*componentShape=*/mlir::Value{}, triplets,
/*substring=*/mlir::ValueRange{}, /*complexPartAttr=*/std::nullopt,
@@ -1571,14 +1575,14 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
llvm::SmallVector<mlir::Value> extents;
mlir::Type idxTy = builder.getIndexType();
for (auto extent : seqTy.getShape()) {
- mlir::Value lb = mlir::arith::ConstantOp::create(builder,
- loc, idxTy, builder.getIntegerAttr(idxTy, 0));
- mlir::Value ub = mlir::arith::ConstantOp::create(builder,
- loc, idxTy, builder.getIntegerAttr(idxTy, extent - 1));
- mlir::Value step = mlir::arith::ConstantOp::create(builder,
- loc, idxTy, builder.getIntegerAttr(idxTy, 1));
+ mlir::Value lb = mlir::arith::ConstantOp::create(
+ builder, loc, idxTy, builder.getIntegerAttr(idxTy, 0));
+ mlir::Value ub = mlir::arith::ConstantOp::create(
+ builder, loc, idxTy, builder.getIntegerAttr(idxTy, extent - 1));
+ mlir::Value step = mlir::arith::ConstantOp::create(
+ builder, loc, idxTy, builder.getIntegerAttr(idxTy, 1));
auto loop = fir::DoLoopOp::create(builder, loc, lb, ub, step,
- /*unordered=*/false);
+ /*unordered=*/false);
builder.setInsertionPointToStart(loop.getBody());
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
@@ -1595,7 +1599,7 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
genConstantBounds(builder, loc, dataBound);
auto loop =
fir::DoLoopOp::create(builder, loc, values[0], values[1], values[2],
- /*unordered=*/false);
+ /*unordered=*/false);
builder.setInsertionPointToStart(loop.getBody());
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
@@ -1612,7 +1616,7 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
mlir::Value ub = recipe.getCombinerRegion().getArgument(i + 1);
mlir::Value step = recipe.getCombinerRegion().getArgument(i + 2);
auto loop = fir::DoLoopOp::create(builder, loc, lb, ub, step,
- /*unordered=*/false);
+ /*unordered=*/false);
builder.setInsertionPointToStart(loop.getBody());
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
@@ -1658,14 +1662,14 @@ static void genCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
getSubscriptsFromArgs(recipe.getCombinerRegion().getArguments());
auto leftEntity = hlfir::Entity{value1};
if (fir::isBoxAddress(value1.getType()))
- leftEntity =
- hlfir::Entity{fir::LoadOp::create(builder, loc, value1).getResult()};
+ leftEntity = hlfir::Entity{
+ fir::LoadOp::create(builder, loc, value1).getResult()};
auto left =
genDesignateWithTriplets(builder, loc, leftEntity, triplets, shape);
auto rightEntity = hlfir::Entity{value2};
if (fir::isBoxAddress(value2.getType()))
- rightEntity =
- hlfir::Entity{fir::LoadOp::create(builder, loc, value2).getResult()};
+ rightEntity = hlfir::Entity{
+ fir::LoadOp::create(builder, loc, value2).getResult()};
auto right =
genDesignateWithTriplets(builder, loc, rightEntity, triplets, shape);
@@ -3750,8 +3754,8 @@ genACCUpdateOp(Fortran::lower::AbstractConverter &converter,
dataClauseOperands.append(updateHostOperands);
- mlir::acc::UpdateOp::create(builder,
- currentLocation, ifCond, asyncOperands,
+ mlir::acc::UpdateOp::create(
+ builder, currentLocation, ifCond, asyncOperands,
getArrayAttr(builder, asyncOperandsDeviceTypes),
getArrayAttr(builder, asyncOnlyDeviceTypes), waitOperands,
getDenseI32ArrayAttr(builder, waitOperandsSegments),
@@ -3878,8 +3882,9 @@ static void createDeclareGlobalOp(mlir::OpBuilder &modBuilder,
declareGlobalOp.getRegion().end(), {}, {});
builder.setInsertionPointToEnd(&declareGlobalOp.getRegion().back());
- fir::AddrOfOp addrOp = fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+ fir::AddrOfOp addrOp = fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(globalOp.getType()),
+ globalOp.getSymbol());
addDeclareAttr(builder, addrOp, clause);
llvm::SmallVector<mlir::Value> bounds;
@@ -3888,19 +3893,19 @@ static void createDeclareGlobalOp(mlir::OpBuilder &modBuilder,
/*structured=*/false, implicit, clause, addrOp.getResTy().getType(),
/*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
if constexpr (std::is_same_v<DeclareOp, mlir::acc::DeclareEnterOp>)
- DeclareOp::create(builder,
- loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()),
- mlir::ValueRange(entryOp.getAccVar()));
+ DeclareOp::create(builder, loc,
+ mlir::acc::DeclareTokenType::get(entryOp.getContext()),
+ mlir::ValueRange(entryOp.getAccVar()));
else
DeclareOp::create(builder, loc, mlir::Value{},
- mlir::ValueRange(entryOp.getAccVar()));
+ mlir::ValueRange(entryOp.getAccVar()));
if constexpr (std::is_same_v<GlobalOp, mlir::acc::GlobalDestructorOp>) {
ExitOp::create(builder, entryOp.getLoc(), entryOp.getAccVar(),
- entryOp.getBounds(), entryOp.getAsyncOperands(),
- entryOp.getAsyncOperandsDeviceTypeAttr(),
- entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
- /*structured=*/false, /*implicit=*/false,
- builder.getStringAttr(*entryOp.getName()));
+ entryOp.getBounds(), entryOp.getAsyncOperands(),
+ entryOp.getAsyncOperandsDeviceTypeAttr(),
+ entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
+ /*structured=*/false, /*implicit=*/false,
+ builder.getStringAttr(*entryOp.getName()));
}
mlir::acc::TerminatorOp::create(builder, loc);
modBuilder.setInsertionPointAfter(declareGlobalOp);
@@ -3917,8 +3922,9 @@ static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder,
auto registerFuncOp =
createDeclareFunc(modBuilder, builder, loc, registerFuncName.str());
- fir::AddrOfOp addrOp = fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+ fir::AddrOfOp addrOp = fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(globalOp.getType()),
+ globalOp.getSymbol());
std::stringstream asFortran;
asFortran << Fortran::lower::mangle::demangleName(globalOp.getSymName());
@@ -3948,8 +3954,8 @@ static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder,
builder, loc, boxAddrOp.getResult(), asFortran, bounds,
/*structured=*/false, /*implicit=*/false, clause, boxAddrOp.getType(),
/*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
- mlir::acc::DeclareEnterOp::create(builder,
- loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()),
+ mlir::acc::DeclareEnterOp::create(
+ builder, loc, mlir::acc::DeclareTokenType::get(entryOp.getContext()),
mlir::ValueRange(entryOp.getAccVar()));
}
@@ -3980,8 +3986,9 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder,
auto preDeallocOp =
createDeclareFunc(modBuilder, builder, loc, preDeallocFuncName.str());
- fir::AddrOfOp addrOp = fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+ fir::AddrOfOp addrOp = fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(globalOp.getType()),
+ globalOp.getSymbol());
auto loadOp = fir::LoadOp::create(builder, loc, addrOp.getResult());
fir::BoxAddrOp boxAddrOp = fir::BoxAddrOp::create(builder, loc, loadOp);
mlir::Value var = boxAddrOp.getResult();
@@ -3994,25 +4001,25 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder,
/*structured=*/false, /*implicit=*/false, clause, var.getType(),
/*async=*/{}, /*asyncDeviceTypes=*/{}, /*asyncOnlyDeviceTypes=*/{});
- mlir::acc::DeclareExitOp::create(builder,
- loc, mlir::Value{}, mlir::ValueRange(entryOp.getAccVar()));
+ mlir::acc::DeclareExitOp::create(builder, loc, mlir::Value{},
+ mlir::ValueRange(entryOp.getAccVar()));
if constexpr (std::is_same_v<ExitOp, mlir::acc::CopyoutOp> ||
std::is_same_v<ExitOp, mlir::acc::UpdateHostOp>)
- ExitOp::create(builder,
- entryOp.getLoc(), entryOp.getAccVar(), entryOp.getVar(),
- entryOp.getBounds(), entryOp.getAsyncOperands(),
- entryOp.getAsyncOperandsDeviceTypeAttr(), entryOp.getAsyncOnlyAttr(),
- entryOp.getDataClause(),
- /*structured=*/false, /*implicit=*/false,
- builder.getStringAttr(*entryOp.getName()));
+ ExitOp::create(builder, entryOp.getLoc(), entryOp.getAccVar(),
+ entryOp.getVar(), entryOp.getBounds(),
+ entryOp.getAsyncOperands(),
+ entryOp.getAsyncOperandsDeviceTypeAttr(),
+ entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
+ /*structured=*/false, /*implicit=*/false,
+ builder.getStringAttr(*entryOp.getName()));
else
- ExitOp::create(builder,
- entryOp.getLoc(), entryOp.getAccVar(), entryOp.getBounds(),
- entryOp.getAsyncOperands(), entryOp.getAsyncOperandsDeviceTypeAttr(),
- entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
- /*structured=*/false, /*implicit=*/false,
- builder.getStringAttr(*entryOp.getName()));
+ ExitOp::create(builder, entryOp.getLoc(), entryOp.getAccVar(),
+ entryOp.getBounds(), entryOp.getAsyncOperands(),
+ entryOp.getAsyncOperandsDeviceTypeAttr(),
+ entryOp.getAsyncOnlyAttr(), entryOp.getDataClause(),
+ /*structured=*/false, /*implicit=*/false,
+ builder.getStringAttr(*entryOp.getName()));
// Generate the post dealloc function.
modBuilder.setInsertionPointAfter(preDeallocOp);
@@ -4024,8 +4031,9 @@ static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder,
auto postDeallocOp =
createDeclareFunc(modBuilder, builder, loc, postDeallocFuncName.str());
- fir::AddrOfOp addrOp = fir::AddrOfOp::create(builder,
- loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+ fir::AddrOfOp addrOp = fir::AddrOfOp::create(
+ builder, loc, fir::ReferenceType::get(globalOp.getType()),
+ globalOp.getSymbol());
if (unwrapFirBox)
asFortran << accFirDescriptorPostfix.str();
llvm::SmallVector<mlir::Value> bounds;
@@ -4262,13 +4270,13 @@ genDeclareInFunction(Fortran::lower::AbstractConverter &converter,
auto ops = funcOp.getOps<mlir::acc::DeclareEnterOp>();
mlir::Value declareToken;
if (ops.empty()) {
- declareToken = mlir::acc::DeclareEnterOp::create(builder,
- loc, mlir::acc::DeclareTokenType::get(builder.getContext()),
+ declareToken = mlir::acc::DeclareEnterOp::create(
+ builder, loc, mlir::acc::DeclareTokenType::get(builder.getContext()),
dataClauseOperands);
} else {
auto declareOp = *ops.begin();
- auto newDeclareOp = mlir::acc::DeclareEnterOp::create(builder,
- loc, mlir::acc::DeclareTokenType::get(builder.getContext()),
+ auto newDeclareOp = mlir::acc::DeclareEnterOp::create(
+ builder, loc, mlir::acc::DeclareTokenType::get(builder.getContext()),
declareOp.getDataClauseOperands());
newDeclareOp.getDataClauseOperandsMutable().append(dataClauseOperands);
declareToken = newDeclareOp.getToken();
@@ -4535,8 +4543,8 @@ void createOpenACCRoutineConstruct(
std::string routineOpStr = routineOpName.str();
mlir::OpBuilder modBuilder(mod.getBodyRegion());
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
- mlir::acc::RoutineOp::create(modBuilder,
- loc, routineOpStr,
+ mlir::acc::RoutineOp::create(
+ modBuilder, loc, routineOpStr,
mlir::SymbolRefAttr::get(builder.getContext(), funcName),
getArrayAttrOrNull(builder, bindIdNames),
getArrayAttrOrNull(builder, bindStrNames),
diff --git a/flang/lib/Lower/OpenMP/Atomic.cpp b/flang/lib/Lower/OpenMP/Atomic.cpp
index 6794144de..9a233d2d8 100644
--- a/flang/lib/Lower/OpenMP/Atomic.cpp
+++ b/flang/lib/Lower/OpenMP/Atomic.cpp
@@ -528,8 +528,8 @@ genAtomicRead(lower::AbstractConverter &converter,
}();
builder.restoreInsertionPoint(atomicAt);
- mlir::Operation *op = mlir::omp::AtomicReadOp::create(builder,
- loc, atomAddr, toAddr, mlir::TypeAttr::get(atomType), hint,
+ mlir::Operation *op = mlir::omp::AtomicReadOp::create(
+ builder, loc, atomAddr, toAddr, mlir::TypeAttr::get(atomType), hint,
makeMemOrderAttr(converter, memOrder));
if (atomType != storeType) {
@@ -581,8 +581,9 @@ genAtomicWrite(lower::AbstractConverter &converter,
mlir::Value converted = builder.createConvert(loc, atomType, value);
builder.restoreInsertionPoint(atomicAt);
- mlir::Operation *op = mlir::omp::AtomicWriteOp::create(builder,
- loc, atomAddr, converted, hint, makeMemOrderAttr(converter, memOrder));
+ mlir::Operation *op =
+ mlir::omp::AtomicWriteOp::create(builder, loc, atomAddr, converted, hint,
+ makeMemOrderAttr(converter, memOrder));
return op;
}
@@ -635,8 +636,8 @@ genAtomicUpdate(lower::AbstractConverter &converter,
}
builder.restoreInsertionPoint(atomicAt);
- auto updateOp = mlir::omp::AtomicUpdateOp::create(builder,
- loc, atomAddr, hint, makeMemOrderAttr(converter, memOrder));
+ auto updateOp = mlir::omp::AtomicUpdateOp::create(
+ builder, loc, atomAddr, hint, makeMemOrderAttr(converter, memOrder));
mlir::Region ®ion = updateOp->getRegion(0);
mlir::Block *block = builder.createBlock(®ion, {}, {atomType}, {loc});
@@ -731,8 +732,8 @@ void Fortran::lower::omp::lowerAtomic(
"Expexcing two actions");
(void)action0;
(void)action1;
- captureOp = mlir::omp::AtomicCaptureOp::create(builder,
- loc, hint, makeMemOrderAttr(converter, memOrder));
+ captureOp = mlir::omp::AtomicCaptureOp::create(
+ builder, loc, hint, makeMemOrderAttr(converter, memOrder));
// Set the non-atomic insertion point to before the atomic.capture.
preAt = getInsertionPointBefore(captureOp);
diff --git a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
index d118bfffa..498eea471 100644
--- a/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/ClauseProcessor.cpp
@@ -831,10 +831,10 @@ createCopyFunc(mlir::Location loc, lower::AbstractConverter &converter,
// get the actual fir.ref<fir.char> type
mlir::Type refType =
fir::ReferenceType::get(mlir::cast<fir::BoxCharType>(eleTy).getEleTy());
- auto unboxedDst = fir::UnboxCharOp::create(builder,
- loc, refType, builder.getIndexType(), loadDst);
- auto unboxedSrc = fir::UnboxCharOp::create(builder,
- loc, refType, builder.getIndexType(), loadSrc);
+ auto unboxedDst = fir::UnboxCharOp::create(builder, loc, refType,
+ builder.getIndexType(), loadDst);
+ auto unboxedSrc = fir::UnboxCharOp::create(builder, loc, refType,
+ builder.getIndexType(), loadSrc);
// Add length to type parameters
typeparams.push_back(unboxedDst.getResult(1));
dst = unboxedDst.getResult(0);
@@ -844,11 +844,11 @@ createCopyFunc(mlir::Location loc, lower::AbstractConverter &converter,
loc, builder.getCharacterLengthType(), *typeInfo.getCharLength());
typeparams.push_back(charLen);
}
- auto declDst = hlfir::DeclareOp::create(builder,
- loc, dst, copyFuncName + "_dst", shape, typeparams,
+ auto declDst = hlfir::DeclareOp::create(
+ builder, loc, dst, copyFuncName + "_dst", shape, typeparams,
/*dummy_scope=*/nullptr, attrs);
- auto declSrc = hlfir::DeclareOp::create(builder,
- loc, src, copyFuncName + "_src", shape, typeparams,
+ auto declSrc = hlfir::DeclareOp::create(
+ builder, loc, src, copyFuncName + "_src", shape, typeparams,
/*dummy_scope=*/nullptr, attrs);
converter.copyVar(loc, declDst.getBase(), declSrc.getBase(), varAttrs);
mlir::func::ReturnOp::create(builder, loc);
@@ -1002,8 +1002,8 @@ bool ClauseProcessor::processDepend(lower::SymMap &symMap,
// allocations so this is not a reliable way to identify the dependency.
if (auto ref = mlir::dyn_cast<fir::ReferenceType>(dependVar.getType()))
if (fir::isa_box_type(ref.getElementType()))
- dependVar = fir::LoadOp::create(builder,
- converter.getCurrentLocation(), dependVar);
+ dependVar = fir::LoadOp::create(
+ builder, converter.getCurrentLocation(), dependVar);
// The openmp dialect doesn't know what to do with boxes (and it would
// break layering to teach it about them). The dependency variable can be
@@ -1012,8 +1012,8 @@ bool ClauseProcessor::processDepend(lower::SymMap &symMap,
// Getting the address of the box data is okay because all the runtime
// ultimately cares about is the base address of the array.
if (fir::isa_box_type(dependVar.getType()))
- dependVar = fir::BoxAddrOp::create(builder,
- converter.getCurrentLocation(), dependVar);
+ dependVar = fir::BoxAddrOp::create(
+ builder, converter.getCurrentLocation(), dependVar);
result.dependVars.push_back(dependVar);
}
diff --git a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
index def5297ba..11e488371 100644
--- a/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
+++ b/flang/lib/Lower/OpenMP/DataSharingProcessor.cpp
@@ -355,14 +355,14 @@ void DataSharingProcessor::insertLastPrivateCompare(mlir::Operation *op) {
vs.push_back(v);
mlir::Value zero =
firOpBuilder.createIntegerConstant(loc, step.getType(), 0);
- mlir::Value negativeStep = mlir::arith::CmpIOp::create(firOpBuilder,
- loc, mlir::arith::CmpIPredicate::slt, step, zero);
- mlir::Value vLT = mlir::arith::CmpIOp::create(firOpBuilder,
- loc, mlir::arith::CmpIPredicate::slt, v, ub);
- mlir::Value vGT = mlir::arith::CmpIOp::create(firOpBuilder,
- loc, mlir::arith::CmpIPredicate::sgt, v, ub);
- mlir::Value icmpOp = mlir::arith::SelectOp::create(firOpBuilder,
- loc, negativeStep, vLT, vGT);
+ mlir::Value negativeStep = mlir::arith::CmpIOp::create(
+ firOpBuilder, loc, mlir::arith::CmpIPredicate::slt, step, zero);
+ mlir::Value vLT = mlir::arith::CmpIOp::create(
+ firOpBuilder, loc, mlir::arith::CmpIPredicate::slt, v, ub);
+ mlir::Value vGT = mlir::arith::CmpIOp::create(
+ firOpBuilder, loc, mlir::arith::CmpIPredicate::sgt, v, ub);
+ mlir::Value icmpOp = mlir::arith::SelectOp::create(
+ firOpBuilder, loc, negativeStep, vLT, vGT);
if (cmpOp)
cmpOp = mlir::arith::AndIOp::create(firOpBuilder, loc, cmpOp, icmpOp);
diff --git a/flang/lib/Lower/OpenMP/OpenMP.cpp b/flang/lib/Lower/OpenMP/OpenMP.cpp
index 8d906550a..80905aa29 100644
--- a/flang/lib/Lower/OpenMP/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP/OpenMP.cpp
@@ -642,8 +642,8 @@ static void threadPrivatizeVars(lower::AbstractConverter &converter,
op = declOp.getMemref().getDefiningOp();
if (mlir::isa<mlir::omp::ThreadprivateOp>(op))
symValue = mlir::dyn_cast<mlir::omp::ThreadprivateOp>(op).getSymAddr();
- return mlir::omp::ThreadprivateOp::create(firOpBuilder,
- currentLocation, symValue.getType(), symValue);
+ return mlir::omp::ThreadprivateOp::create(firOpBuilder, currentLocation,
+ symValue.getType(), symValue);
};
llvm::SetVector<const semantics::Symbol *> threadprivateSyms;
@@ -1157,7 +1157,7 @@ static void createBodyOfOp(mlir::Operation &op, const OpWithBodyGenInfo &info,
auto insertMarker = [](fir::FirOpBuilder &builder) {
mlir::Value undef = fir::UndefOp::create(builder, builder.getUnknownLoc(),
- builder.getIndexType());
+ builder.getIndexType());
return undef.getDefiningOp();
};
@@ -1332,8 +1332,8 @@ static void genBodyOfTargetDataOp(
// Remembering the position for further insertion is important since
// there are hlfir.declares inserted above while setting block arguments
// and new code from the body should be inserted after that.
- mlir::Value undefMarker = fir::UndefOp::create(firOpBuilder,
- dataOp.getLoc(), firOpBuilder.getIndexType());
+ mlir::Value undefMarker = fir::UndefOp::create(firOpBuilder, dataOp.getLoc(),
+ firOpBuilder.getIndexType());
// Create blocks for unstructured regions. This has to be done since
// blocks are initially allocated with the function as the parent region.
@@ -1497,7 +1497,7 @@ static void genBodyOfTargetOp(
firOpBuilder.setInsertionPointToStart(entryBlock);
auto loadOp = fir::LoadOp::create(firOpBuilder, clonedValArg.getLoc(),
- clonedValArg);
+ clonedValArg);
val.replaceUsesWithIf(loadOp->getResult(0),
[entryBlock](mlir::OpOperand &use) {
return use.getOwner()->getBlock() == entryBlock;
@@ -1513,8 +1513,8 @@ static void genBodyOfTargetOp(
// marker will be deleted since there are not uses.
// In the HLFIR flow there are hlfir.declares inserted above while
// setting block arguments.
- mlir::Value undefMarker = fir::UndefOp::create(firOpBuilder,
- targetOp.getLoc(), firOpBuilder.getIndexType());
+ mlir::Value undefMarker = fir::UndefOp::create(
+ firOpBuilder, targetOp.getLoc(), firOpBuilder.getIndexType());
// Create blocks for unstructured regions. This has to be done since
// blocks are initially allocated with the function as the parent region.
@@ -3342,8 +3342,8 @@ genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
firOpBuilder.setInsertionPointToStart(converter.getModuleOp().getBody());
auto mlirType = converter.genType(varType.declTypeSpec->derivedTypeSpec());
- auto declMapperOp = mlir::omp::DeclareMapperOp::create(firOpBuilder,
- loc, mapperNameStr, mlirType);
+ auto declMapperOp = mlir::omp::DeclareMapperOp::create(
+ firOpBuilder, loc, mapperNameStr, mlirType);
auto ®ion = declMapperOp.getRegion();
firOpBuilder.createBlock(®ion);
auto varVal = region.addArgument(firOpBuilder.getRefType(mlirType), loc);
@@ -3819,9 +3819,8 @@ void Fortran::lower::genThreadprivateOp(lower::AbstractConverter &converter,
return;
}
// Generate ThreadprivateOp and rebind the common block.
- mlir::Value commonThreadprivateValue =
- mlir::omp::ThreadprivateOp::create(firOpBuilder,
- currentLocation, commonValue.getType(), commonValue);
+ mlir::Value commonThreadprivateValue = mlir::omp::ThreadprivateOp::create(
+ firOpBuilder, currentLocation, commonValue.getType(), commonValue);
converter.bindSymbol(*common, commonThreadprivateValue);
// Generate the threadprivate value for the common block member.
symThreadprivateValue = genCommonBlockMember(converter, currentLocation,
@@ -3841,10 +3840,10 @@ void Fortran::lower::genThreadprivateOp(lower::AbstractConverter &converter,
global = globalInitialization(converter, firOpBuilder, sym, var,
currentLocation);
- mlir::Value symValue = fir::AddrOfOp::create(firOpBuilder,
- currentLocation, global.resultType(), global.getSymbol());
- symThreadprivateValue = mlir::omp::ThreadprivateOp::create(firOpBuilder,
- currentLocation, symValue.getType(), symValue);
+ mlir::Value symValue = fir::AddrOfOp::create(
+ firOpBuilder, currentLocation, global.resultType(), global.getSymbol());
+ symThreadprivateValue = mlir::omp::ThreadprivateOp::create(
+ firOpBuilder, currentLocation, symValue.getType(), symValue);
} else {
mlir::Value symValue = converter.getSymbolAddress(sym);
@@ -3859,8 +3858,8 @@ void Fortran::lower::genThreadprivateOp(lower::AbstractConverter &converter,
if (mlir::isa<mlir::omp::ThreadprivateOp>(op))
return;
- symThreadprivateValue = mlir::omp::ThreadprivateOp::create(firOpBuilder,
- currentLocation, symValue.getType(), symValue);
+ symThreadprivateValue = mlir::omp::ThreadprivateOp::create(
+ firOpBuilder, currentLocation, symValue.getType(), symValue);
}
fir::ExtendedValue sexv = converter.getSymbolExtendedValue(sym);
diff --git a/flang/lib/Lower/OpenMP/Utils.cpp b/flang/lib/Lower/OpenMP/Utils.cpp
index 83752fa62..b1716d6af 100644
--- a/flang/lib/Lower/OpenMP/Utils.cpp
+++ b/flang/lib/Lower/OpenMP/Utils.cpp
@@ -129,8 +129,8 @@ createMapInfoOp(fir::FirOpBuilder &builder, mlir::Location loc,
if (seqType.hasDynamicExtents())
varType = mlir::TypeAttr::get(seqType.getEleTy());
- mlir::omp::MapInfoOp op = mlir::omp::MapInfoOp::create(builder,
- loc, retTy, baseAddr, varType,
+ mlir::omp::MapInfoOp op = mlir::omp::MapInfoOp::create(
+ builder, loc, retTy, baseAddr, varType,
builder.getIntegerAttr(builder.getIntegerType(64, false), mapType),
builder.getAttr<mlir::omp::VariableCaptureKindAttr>(mapCaptureType),
varPtrPtr, members, membersIndex, bounds, mapperId,
@@ -196,7 +196,7 @@ static void generateArrayIndices(lower::AbstractConverter &converter,
subscript = firOpBuilder.createConvert(
clauseLocation, firOpBuilder.getIndexType(), subscript);
indices.push_back(mlir::arith::SubIOp::create(firOpBuilder, clauseLocation,
- subscript, one));
+ subscript, one));
}
}
@@ -329,9 +329,10 @@ mlir::Value createParentSymAndGenIntermediateMaps(
subscriptIndices, objectList[i]);
assert(!subscriptIndices.empty() &&
"missing expected indices for map clause");
- curValue = fir::CoordinateOp::create(firOpBuilder,
- clauseLocation, firOpBuilder.getRefType(arrType.getEleTy()),
- curValue, subscriptIndices);
+ curValue = fir::CoordinateOp::create(
+ firOpBuilder, clauseLocation,
+ firOpBuilder.getRefType(arrType.getEleTy()), curValue,
+ subscriptIndices);
}
}
@@ -345,9 +346,9 @@ mlir::Value createParentSymAndGenIntermediateMaps(
fir::IntOrValue idxConst = mlir::IntegerAttr::get(
firOpBuilder.getI32Type(), indices[currentIndicesIdx]);
mlir::Type memberTy = recordType.getType(indices[currentIndicesIdx]);
- curValue = fir::CoordinateOp::create(firOpBuilder,
- clauseLocation, firOpBuilder.getRefType(memberTy), curValue,
- llvm::SmallVector<fir::IntOrValue, 1>{idxConst});
+ curValue = fir::CoordinateOp::create(
+ firOpBuilder, clauseLocation, firOpBuilder.getRefType(memberTy),
+ curValue, llvm::SmallVector<fir::IntOrValue, 1>{idxConst});
// If we're a final member, the map will be generated by the processMap
// call that invoked this function.
diff --git a/flang/lib/Lower/Support/PrivateReductionUtils.cpp b/flang/lib/Lower/Support/PrivateReductionUtils.cpp
index 4c446c324..fff060b79 100644
--- a/flang/lib/Lower/Support/PrivateReductionUtils.cpp
+++ b/flang/lib/Lower/Support/PrivateReductionUtils.cpp
@@ -393,7 +393,7 @@ void PopulateInitAndCleanupRegionsHelper::initBoxedPrivatePointer(
mlir::Value null = builder.createNullConstant(loc, boxTy.getEleTy());
mlir::Value nullBox;
nullBox = fir::EmboxOp::create(builder, loc, boxTy, null, shape,
- /*slice=*/mlir::Value{}, lenParams);
+ /*slice=*/mlir::Value{}, lenParams);
fir::StoreOp::create(builder, loc, nullBox, allocatedPrivVarArg);
createYield(allocatedPrivVarArg);
}
@@ -413,7 +413,7 @@ fir::IfOp PopulateInitAndCleanupRegionsHelper::handleNullAllocatable() {
mlir::Value addr = fir::BoxAddrOp::create(builder, loc, getLoadedMoldArg());
mlir::Value isNotAllocated = builder.genIsNullAddr(loc, addr);
fir::IfOp ifOp = fir::IfOp::create(builder, loc, isNotAllocated,
- /*withElseRegion=*/true);
+ /*withElseRegion=*/true);
builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
// Just embox the null address and return.
// We have to give the embox a shape so that the LLVM box structure has the
@@ -422,7 +422,7 @@ fir::IfOp PopulateInitAndCleanupRegionsHelper::handleNullAllocatable() {
mlir::Value nullBox =
fir::EmboxOp::create(builder, loc, valType, addr, shape,
- /*slice=*/mlir::Value{}, lenParams);
+ /*slice=*/mlir::Value{}, lenParams);
fir::StoreOp::create(builder, loc, nullBox, allocatedPrivVarArg);
return ifOp;
}
@@ -442,9 +442,9 @@ void PopulateInitAndCleanupRegionsHelper::initAndCleanupBoxedScalar(
/*shape=*/{}, lenParams);
if (scalarInitValue)
builder.createStoreWithConvert(loc, scalarInitValue, valAlloc);
- mlir::Value box = fir::EmboxOp::create(builder,
- loc, valType, valAlloc, /*shape=*/mlir::Value{},
- /*slice=*/mlir::Value{}, lenParams);
+ mlir::Value box = fir::EmboxOp::create(builder, loc, valType, valAlloc,
+ /*shape=*/mlir::Value{},
+ /*slice=*/mlir::Value{}, lenParams);
initializeIfDerivedTypeBox(
builder, loc, box, getLoadedMoldArg(), needsInitialization,
/*isFirstPrivate=*/kind == DeclOperationKind::FirstPrivateOrLocalInit);
@@ -483,10 +483,11 @@ void PopulateInitAndCleanupRegionsHelper::initAndCleanupBoxedArray(
fir::ShapeShiftOp shape =
getShapeShift(builder, loc, source, cannotHaveNonDefaultLowerBounds);
mlir::Type arrayType = source.getElementOrSequenceType();
- mlir::Value allocatedArray = fir::AllocMemOp::create(builder,
- loc, arrayType, /*typeparams=*/mlir::ValueRange{}, shape.getExtents());
+ mlir::Value allocatedArray = fir::AllocMemOp::create(
+ builder, loc, arrayType, /*typeparams=*/mlir::ValueRange{},
+ shape.getExtents());
mlir::Value firClass = fir::EmboxOp::create(builder, loc, source.getType(),
- allocatedArray, shape);
+ allocatedArray, shape);
initializeIfDerivedTypeBox(
builder, loc, firClass, source, needsInitialization,
/*isFirstprivate=*/kind == DeclOperationKind::FirstPrivateOrLocalInit);
@@ -544,12 +545,11 @@ void PopulateInitAndCleanupRegionsHelper::initAndCleanupBoxedArray(
// the box created by the declare form createTempFromMold is missing
// lower bounds info
box = fir::ReboxOp::create(builder, loc, boxType, temp, shapeShift,
- /*shift=*/mlir::Value{});
+ /*shift=*/mlir::Value{});
else
- box = fir::EmboxOp::create(builder,
- loc, boxType, temp, shapeShift,
- /*slice=*/mlir::Value{},
- /*typeParams=*/llvm::ArrayRef<mlir::Value>{});
+ box = fir::EmboxOp::create(builder, loc, boxType, temp, shapeShift,
+ /*slice=*/mlir::Value{},
+ /*typeParams=*/llvm::ArrayRef<mlir::Value>{});
if (scalarInitValue)
hlfir::AssignOp::create(builder, loc, scalarInitValue, box);
diff --git a/flang/lib/Lower/Support/ReductionProcessor.cpp b/flang/lib/Lower/Support/ReductionProcessor.cpp
index ee73ead79..80c32d066 100644
--- a/flang/lib/Lower/Support/ReductionProcessor.cpp
+++ b/flang/lib/Lower/Support/ReductionProcessor.cpp
@@ -260,20 +260,20 @@ ReductionProcessor::getReductionInitValue(mlir::Location loc, mlir::Type type,
initIm);
}
if (mlir::isa<mlir::FloatType>(type))
- return mlir::arith::ConstantOp::create(builder,
- loc, type,
+ return mlir::arith::ConstantOp::create(
+ builder, loc, type,
builder.getFloatAttr(type, (double)getOperationIdentity(redId, loc)));
if (mlir::isa<fir::LogicalType>(type)) {
- mlir::Value intConst = mlir::arith::ConstantOp::create(builder,
- loc, builder.getI1Type(),
+ mlir::Value intConst = mlir::arith::ConstantOp::create(
+ builder, loc, builder.getI1Type(),
builder.getIntegerAttr(builder.getI1Type(),
getOperationIdentity(redId, loc)));
return builder.createConvert(loc, type, intConst);
}
- return mlir::arith::ConstantOp::create(builder,
- loc, type,
+ return mlir::arith::ConstantOp::create(
+ builder, loc, type,
builder.getIntegerAttr(type, getOperationIdentity(redId, loc)));
case ReductionIdentifier::ID:
case ReductionIdentifier::USER_DEF_OP:
@@ -325,7 +325,8 @@ mlir::Value ReductionProcessor::createScalarCombiner(
mlir::Value op1I1 = builder.createConvert(loc, builder.getI1Type(), op1);
mlir::Value op2I1 = builder.createConvert(loc, builder.getI1Type(), op2);
- mlir::Value andiOp = mlir::arith::AndIOp::create(builder, loc, op1I1, op2I1);
+ mlir::Value andiOp =
+ mlir::arith::AndIOp::create(builder, loc, op1I1, op2I1);
reductionOp = builder.createConvert(loc, type, andiOp);
break;
@@ -343,8 +344,8 @@ mlir::Value ReductionProcessor::createScalarCombiner(
mlir::Value op1I1 = builder.createConvert(loc, builder.getI1Type(), op1);
mlir::Value op2I1 = builder.createConvert(loc, builder.getI1Type(), op2);
- mlir::Value cmpiOp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::eq, op1I1, op2I1);
+ mlir::Value cmpiOp = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::eq, op1I1, op2I1);
reductionOp = builder.createConvert(loc, type, cmpiOp);
break;
@@ -353,8 +354,8 @@ mlir::Value ReductionProcessor::createScalarCombiner(
mlir::Value op1I1 = builder.createConvert(loc, builder.getI1Type(), op1);
mlir::Value op2I1 = builder.createConvert(loc, builder.getI1Type(), op2);
- mlir::Value cmpiOp = mlir::arith::CmpIOp::create(builder,
- loc, mlir::arith::CmpIPredicate::ne, op1I1, op2I1);
+ mlir::Value cmpiOp = mlir::arith::CmpIOp::create(
+ builder, loc, mlir::arith::CmpIPredicate::ne, op1I1, op2I1);
reductionOp = builder.createConvert(loc, type, cmpiOp);
break;
@@ -437,11 +438,11 @@ static void genBoxCombiner(fir::FirOpBuilder &builder, mlir::Location loc,
builder.setInsertionPointToStart(nest.body);
const bool seqIsVolatile = fir::isa_volatile_type(seqTy.getEleTy());
mlir::Type refTy = fir::ReferenceType::get(seqTy.getEleTy(), seqIsVolatile);
- auto lhsEleAddr = fir::ArrayCoorOp::create(builder,
- loc, refTy, lhs, shapeShift, /*slice=*/mlir::Value{},
+ auto lhsEleAddr = fir::ArrayCoorOp::create(
+ builder, loc, refTy, lhs, shapeShift, /*slice=*/mlir::Value{},
nest.oneBasedIndices, /*typeparms=*/mlir::ValueRange{});
- auto rhsEleAddr = fir::ArrayCoorOp::create(builder,
- loc, refTy, rhs, shapeShift, /*slice=*/mlir::Value{},
+ auto rhsEleAddr = fir::ArrayCoorOp::create(
+ builder, loc, refTy, rhs, shapeShift, /*slice=*/mlir::Value{},
nest.oneBasedIndices, /*typeparms=*/mlir::ValueRange{});
auto lhsEle = fir::LoadOp::create(builder, loc, lhsEleAddr);
auto rhsEle = fir::LoadOp::create(builder, loc, rhsEleAddr);
diff --git a/flang/lib/Lower/Support/Utils.cpp b/flang/lib/Lower/Support/Utils.cpp
index 887732294..881401e11 100644
--- a/flang/lib/Lower/Support/Utils.cpp
+++ b/flang/lib/Lower/Support/Utils.cpp
@@ -702,7 +702,8 @@ void privatizeSymbol(
// Boxes should be passed by reference into nested regions:
auto oldIP = firOpBuilder.saveInsertionPoint();
firOpBuilder.setInsertionPointToStart(firOpBuilder.getAllocaBlock());
- auto alloca = fir::AllocaOp::create(firOpBuilder, symLoc, privVal.getType());
+ auto alloca =
+ fir::AllocaOp::create(firOpBuilder, symLoc, privVal.getType());
firOpBuilder.restoreInsertionPoint(oldIP);
fir::StoreOp::create(firOpBuilder, symLoc, privVal, alloca);
privVal = alloca;
@@ -726,15 +727,15 @@ void privatizeSymbol(
OpType result;
if constexpr (std::is_same_v<OpType, mlir::omp::PrivateClauseOp>) {
- result = OpType::create(firOpBuilder,
- symLoc, uniquePrivatizerName, allocType,
+ result = OpType::create(
+ firOpBuilder, symLoc, uniquePrivatizerName, allocType,
emitCopyRegion ? mlir::omp::DataSharingClauseType::FirstPrivate
: mlir::omp::DataSharingClauseType::Private);
} else {
- result = OpType::create(firOpBuilder,
- symLoc, uniquePrivatizerName, allocType,
- emitCopyRegion ? fir::LocalitySpecifierType::LocalInit
- : fir::LocalitySpecifierType::Local);
+ result =
+ OpType::create(firOpBuilder, symLoc, uniquePrivatizerName, allocType,
+ emitCopyRegion ? fir::LocalitySpecifierType::LocalInit
+ : fir::LocalitySpecifierType::Local);
}
fir::ExtendedValue symExV = converter.getSymbolExtendedValue(*sym);
@@ -815,12 +816,12 @@ void privatizeSymbol(
copyFirstPrivateSymbol(converter, symToPrivatize, &ip);
if constexpr (std::is_same_v<OpType, mlir::omp::PrivateClauseOp>) {
- mlir::omp::YieldOp::create(firOpBuilder,
- hsb.getAddr().getLoc(),
+ mlir::omp::YieldOp::create(
+ firOpBuilder, hsb.getAddr().getLoc(),
symTable.shallowLookupSymbol(*symToPrivatize).getAddr());
} else {
- fir::YieldOp::create(firOpBuilder,
- hsb.getAddr().getLoc(),
+ fir::YieldOp::create(
+ firOpBuilder, hsb.getAddr().getLoc(),
symTable.shallowLookupSymbol(*symToPrivatize).getAddr());
}
}
diff --git a/flang/lib/Lower/VectorSubscripts.cpp b/flang/lib/Lower/VectorSubscripts.cpp
index a859d9a28..4d1d6fb28 100644
--- a/flang/lib/Lower/VectorSubscripts.cpp
+++ b/flang/lib/Lower/VectorSubscripts.cpp
@@ -121,8 +121,9 @@ private:
if (recTy.getNumLenParams() != 0)
TODO(loc, "threading length parameters in field index op");
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
- componentPath.emplace_back(fir::FieldIndexOp::create(builder,
- loc, fldTy, componentName, recTy, /*typeParams=*/mlir::ValueRange{}));
+ componentPath.emplace_back(
+ fir::FieldIndexOp::create(builder, loc, fldTy, componentName, recTy,
+ /*typeParams=*/mlir::ValueRange{}));
return fir::unwrapSequenceType(recTy.getType(componentName));
}
@@ -269,16 +270,16 @@ mlir::Value Fortran::lower::VectorSubscriptBox::loopOverElementsBase(
for (auto [lb, ub, step] : genLoopBounds(builder, loc)) {
LoopType loop;
if constexpr (std::is_same_v<LoopType, fir::IterWhileOp>) {
- loop =
- fir::IterWhileOp::create(builder, loc, lb, ub, step, initialCondition);
+ loop = fir::IterWhileOp::create(builder, loc, lb, ub, step,
+ initialCondition);
initialCondition = loop.getIterateVar();
if (!outerLoop)
outerLoop = loop;
else
fir::ResultOp::create(builder, loc, loop.getResult(0));
} else {
- loop =
- fir::DoLoopOp::create(builder, loc, lb, ub, step, /*unordered=*/false);
+ loop = fir::DoLoopOp::create(builder, loc, lb, ub, step,
+ /*unordered=*/false);
if (!outerLoop)
outerLoop = loop;
}
@@ -402,8 +403,8 @@ fir::ExtendedValue Fortran::lower::VectorSubscriptBox::getElementAt(
mlir::Type vecEleTy = fir::unwrapSequenceType(
fir::unwrapPassByRefType(vecBase.getType()));
mlir::Type refTy = builder.getRefType(vecEleTy);
- auto vecEltRef = fir::CoordinateOp::create(builder,
- loc, refTy, vecBase, vecIndex);
+ auto vecEltRef = fir::CoordinateOp::create(builder, loc, refTy,
+ vecBase, vecIndex);
auto vecElt =
fir::LoadOp::create(builder, loc, vecEleTy, vecEltRef);
indexes.emplace_back(builder.createConvert(loc, idxTy, vecElt));
@@ -414,8 +415,8 @@ fir::ExtendedValue Fortran::lower::VectorSubscriptBox::getElementAt(
},
subscript);
mlir::Type refTy = builder.getRefType(getElementType());
- auto elementAddr = fir::ArrayCoorOp::create(builder,
- loc, refTy, fir::getBase(loweredBase), shape, slice, indexes,
+ auto elementAddr = fir::ArrayCoorOp::create(
+ builder, loc, refTy, fir::getBase(loweredBase), shape, slice, indexes,
fir::getTypeParams(loweredBase));
fir::ExtendedValue element = fir::factory::arraySectionElementToExtendedValue(
builder, loc, loweredBase, elementAddr, slice);
``````````
</details>
https://github.com/llvm/llvm-project/pull/149912
More information about the flang-commits
mailing list