[flang-commits] [flang] [flang] Do not hoist all scalar sub-expressions from WHERE constructs (PR #91395)
via flang-commits
flang-commits at lists.llvm.org
Tue May 7 13:38:20 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: None (jeanPerier)
<details>
<summary>Changes</summary>
The HLFIR pass lowering WHERE (hlfir.where op) was too aggressive in its hoisting of scalar sub-expressions from LHS/RHS/MASKS outside of the loops generated for the WHERE construct.
This violated F'2023 10.2.3.2 point 10 that stipulated that elemental operations must be evaluated only for elements corresponding to true values, because scalar operations are still elemental, and hoisting them is invalid if they could have side effects (e.g, division by zero) and if the MASK is always false (i.e., the loop body is never evaluated).
The difficulty is that 10.2.3.2 point 9 mandates that nonelemental function must be evaluated before the loops. So it is not possible to simply stop hoisting non hlfir.elemental operations.
Marking calls with an elemental/nonelemental attribute would not allow the pass to be correct if inlining is run before and drops this information, beside, extracting the argument tree that may have been CSE-ed with the rest of the expression evaluation would be a bit combursome.
Instead, lower nonelemental calls into a new hlfir.exactly_once operation that will allow retaining the information that the operations contained inside its region must be hoisted. This allows inlining to operate before if desired in order to improve alias analysis.
The LowerHLFIROrderedAssignments pass is updated to only hoist the operations contained inside hlfir.exactly_once bodies.
---
Patch is 43.58 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/91395.diff
11 Files Affected:
- (modified) flang/include/flang/Lower/StatementContext.h (+14)
- (modified) flang/include/flang/Optimizer/HLFIR/HLFIROps.td (+23-1)
- (modified) flang/lib/Lower/Bridge.cpp (+23-22)
- (modified) flang/lib/Lower/ConvertCall.cpp (+37)
- (modified) flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp (+76-17)
- (modified) flang/test/HLFIR/order_assignments/impure-where.fir (+6-3)
- (modified) flang/test/HLFIR/order_assignments/inlined-stack-temp.fir (+1-1)
- (modified) flang/test/HLFIR/order_assignments/user-defined-assignment-finalization.fir (+18-13)
- (modified) flang/test/HLFIR/order_assignments/where-codegen-no-conflict.fir (+2-2)
- (added) flang/test/HLFIR/order_assignments/where-hoisting.f90 (+50)
- (added) flang/test/Lower/HLFIR/where-nonelemental.f90 (+198)
``````````diff
diff --git a/flang/include/flang/Lower/StatementContext.h b/flang/include/flang/Lower/StatementContext.h
index cec9641d43a08..7776edc93ed73 100644
--- a/flang/include/flang/Lower/StatementContext.h
+++ b/flang/include/flang/Lower/StatementContext.h
@@ -18,6 +18,15 @@
#include <functional>
#include <optional>
+namespace mlir {
+class Location;
+class Region;
+} // namespace mlir
+
+namespace fir {
+class FirOpBuilder;
+}
+
namespace Fortran::lower {
/// When lowering a statement, temporaries for intermediate results may be
@@ -105,6 +114,11 @@ class StatementContext {
llvm::SmallVector<std::optional<CleanupFunction>> cufs;
};
+/// If \p context contains any cleanups, ensure \p region has a block, and
+/// generate the cleanup inside that block.
+void genCleanUpInRegionIfAny(mlir::Location loc, fir::FirOpBuilder &builder,
+ mlir::Region ®ion, StatementContext &context);
+
} // namespace Fortran::lower
#endif // FORTRAN_LOWER_STATEMENTCONTEXT_H
diff --git a/flang/include/flang/Optimizer/HLFIR/HLFIROps.td b/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
index ee3c26800ae3a..fdb21656a27fc 100644
--- a/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
+++ b/flang/include/flang/Optimizer/HLFIR/HLFIROps.td
@@ -1329,7 +1329,8 @@ def hlfir_RegionAssignOp : hlfir_Op<"region_assign", [hlfir_OrderedAssignmentTre
}
def hlfir_YieldOp : hlfir_Op<"yield", [Terminator, ParentOneOf<["RegionAssignOp",
- "ElementalAddrOp", "ForallOp", "ForallMaskOp", "WhereOp", "ElseWhereOp"]>,
+ "ElementalAddrOp", "ForallOp", "ForallMaskOp", "WhereOp", "ElseWhereOp",
+ "ExactlyOnceOp"]>,
SingleBlockImplicitTerminator<"fir::FirEndOp">, RecursivelySpeculatable,
RecursiveMemoryEffects]> {
@@ -1594,6 +1595,27 @@ def hlfir_ForallMaskOp : hlfir_AssignmentMaskOp<"forall_mask"> {
let hasVerifier = 1;
}
+def hlfir_ExactlyOnceOp : hlfir_Op<"exactly_once", [RecursiveMemoryEffects]> {
+ let summary = "Execute exactly once its region in a WhereOp";
+ let description = [{
+ Inside a Where assignment, Fortran requires a non elemental call and its
+ arguments to be executed exactly once, regardless of the mask values.
+ This operation allows holding these evaluations that cannot be hoisted
+ until potential parent Forall loops have been created.
+ It also allows inlining the calls without losing the information that
+ these calls must be hoisted.
+ }];
+
+ let regions = (region SizedRegion<1>:$body);
+
+ let results = (outs AnyFortranEntity:$result);
+
+ let assemblyFormat = [{
+ attr-dict `:` type($result)
+ $body
+ }];
+}
+
def hlfir_WhereOp : hlfir_AssignmentMaskOp<"where"> {
let summary = "Represent a Fortran where construct or statement";
let description = [{
diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp
index ae8679afc603f..beda4d7328525 100644
--- a/flang/lib/Lower/Bridge.cpp
+++ b/flang/lib/Lower/Bridge.cpp
@@ -3677,22 +3677,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
return hlfir::Entity{valueAndPair.first};
}
- static void
- genCleanUpInRegionIfAny(mlir::Location loc, fir::FirOpBuilder &builder,
- mlir::Region ®ion,
- Fortran::lower::StatementContext &context) {
- if (!context.hasCode())
- return;
- mlir::OpBuilder::InsertPoint insertPt = builder.saveInsertionPoint();
- if (region.empty())
- builder.createBlock(®ion);
- else
- builder.setInsertionPointToEnd(®ion.front());
- context.finalizeAndPop();
- hlfir::YieldOp::ensureTerminator(region, builder, loc);
- builder.restoreInsertionPoint(insertPt);
- }
-
bool firstDummyIsPointerOrAllocatable(
const Fortran::evaluate::ProcedureRef &userDefinedAssignment) {
using DummyAttr = Fortran::evaluate::characteristics::DummyDataObject::Attr;
@@ -3918,7 +3902,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
Fortran::lower::StatementContext rhsContext;
hlfir::Entity rhs = evaluateRhs(rhsContext);
auto rhsYieldOp = builder.create<hlfir::YieldOp>(loc, rhs);
- genCleanUpInRegionIfAny(loc, builder, rhsYieldOp.getCleanup(), rhsContext);
+ Fortran::lower::genCleanUpInRegionIfAny(
+ loc, builder, rhsYieldOp.getCleanup(), rhsContext);
// Lower LHS in its own region.
builder.createBlock(®ionAssignOp.getLhsRegion());
Fortran::lower::StatementContext lhsContext;
@@ -3926,15 +3911,15 @@ class FirConverter : public Fortran::lower::AbstractConverter {
if (!lhsHasVectorSubscripts) {
hlfir::Entity lhs = evaluateLhs(lhsContext);
auto lhsYieldOp = builder.create<hlfir::YieldOp>(loc, lhs);
- genCleanUpInRegionIfAny(loc, builder, lhsYieldOp.getCleanup(),
- lhsContext);
+ Fortran::lower::genCleanUpInRegionIfAny(
+ loc, builder, lhsYieldOp.getCleanup(), lhsContext);
lhsYield = lhs;
} else {
hlfir::ElementalAddrOp elementalAddr =
Fortran::lower::convertVectorSubscriptedExprToElementalAddr(
loc, *this, assign.lhs, localSymbols, lhsContext);
- genCleanUpInRegionIfAny(loc, builder, elementalAddr.getCleanup(),
- lhsContext);
+ Fortran::lower::genCleanUpInRegionIfAny(
+ loc, builder, elementalAddr.getCleanup(), lhsContext);
lhsYield = elementalAddr.getYieldOp().getEntity();
}
assert(lhsYield && "must have been set");
@@ -4289,7 +4274,8 @@ class FirConverter : public Fortran::lower::AbstractConverter {
loc, *this, *maskExpr, localSymbols, maskContext);
mask = hlfir::loadTrivialScalar(loc, *builder, mask);
auto yieldOp = builder->create<hlfir::YieldOp>(loc, mask);
- genCleanUpInRegionIfAny(loc, *builder, yieldOp.getCleanup(), maskContext);
+ Fortran::lower::genCleanUpInRegionIfAny(loc, *builder, yieldOp.getCleanup(),
+ maskContext);
}
void genFIR(const Fortran::parser::WhereConstructStmt &stmt) {
const Fortran::semantics::SomeExpr *maskExpr = Fortran::semantics::GetExpr(
@@ -5545,3 +5531,18 @@ Fortran::lower::LoweringBridge::LoweringBridge(
fir::support::setMLIRDataLayout(*module.get(),
targetMachine.createDataLayout());
}
+
+void Fortran::lower::genCleanUpInRegionIfAny(
+ mlir::Location loc, fir::FirOpBuilder &builder, mlir::Region ®ion,
+ Fortran::lower::StatementContext &context) {
+ if (!context.hasCode())
+ return;
+ mlir::OpBuilder::InsertPoint insertPt = builder.saveInsertionPoint();
+ if (region.empty())
+ builder.createBlock(®ion);
+ else
+ builder.setInsertionPointToEnd(®ion.front());
+ context.finalizeAndPop();
+ hlfir::YieldOp::ensureTerminator(region, builder, loc);
+ builder.restoreInsertionPoint(insertPt);
+}
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index 3659dad367b42..f989bc7e017f3 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -2682,10 +2682,47 @@ bool Fortran::lower::isIntrinsicModuleProcRef(
return module && module->attrs().test(Fortran::semantics::Attr::INTRINSIC);
}
+static bool isInWhereMaskedExpression(fir::FirOpBuilder& builder) {
+ // The MASK of the outer WHERE is not masked itself.
+ mlir::Operation* op = builder.getRegion().getParentOp();
+ return op && op->getParentOfType<hlfir::WhereOp>();
+}
+
std::optional<hlfir::EntityWithAttributes> Fortran::lower::convertCallToHLFIR(
mlir::Location loc, Fortran::lower::AbstractConverter &converter,
const evaluate::ProcedureRef &procRef, std::optional<mlir::Type> resultType,
Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx) {
+ auto &builder = converter.getFirOpBuilder();
+ if (resultType && !procRef.IsElemental() && isInWhereMaskedExpression(builder) &&
+ !builder.getRegion().getParentOfType<hlfir::ExactlyOnceOp>()) {
+ // Non elemental calls inside a where-assignment-stmt must be executed
+ // exactly once without mask control. Lower them in a special region so that
+ // this can be enforced whenscheduling forall/where expression evaluations.
+ Fortran::lower::StatementContext localStmtCtx;
+ mlir::Type bogusType = builder.getIndexType();
+ auto exactlyOnce = builder.create<hlfir::ExactlyOnceOp>(loc, bogusType);
+ mlir::Block *block = builder.createBlock(&exactlyOnce.getBody());
+ builder.setInsertionPointToStart(block);
+ CallContext callContext(procRef, resultType, loc, converter, symMap,
+ localStmtCtx);
+ std::optional<hlfir::EntityWithAttributes> res =
+ genProcedureRef(callContext);
+ assert(res.has_value() && "must be a function");
+ auto yield = builder.create<hlfir::YieldOp>(loc, *res);
+ Fortran::lower::genCleanUpInRegionIfAny(loc, builder, yield.getCleanup(),
+ localStmtCtx);
+ builder.setInsertionPointAfter(exactlyOnce);
+ exactlyOnce->getResult(0).setType(res->getType());
+ if (hlfir::isFortranValue(exactlyOnce.getResult()))
+ return hlfir::EntityWithAttributes{exactlyOnce.getResult()};
+ // Create hlfir.declare for the result to satisfy
+ // hlfir::EntityWithAttributes requirements.
+ auto [exv, cleanup] = hlfir::translateToExtendedValue(
+ loc, builder, hlfir::Entity{exactlyOnce});
+ assert(!cleanup && "resut is a variable");
+ return hlfir::genDeclare(loc, builder, exv, ".func.pointer.result",
+ fir::FortranVariableFlagsAttr{});
+ }
CallContext callContext(procRef, resultType, loc, converter, symMap, stmtCtx);
return genProcedureRef(callContext);
}
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
index 63b52c0cd0bc4..e4a9999d48c10 100644
--- a/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
+++ b/flang/lib/Optimizer/HLFIR/Transforms/LowerHLFIROrderedAssignments.cpp
@@ -56,7 +56,8 @@ namespace {
/// expression and allows splitting the generation of the none elemental part
/// from the elemental part.
struct MaskedArrayExpr {
- MaskedArrayExpr(mlir::Location loc, mlir::Region ®ion);
+ MaskedArrayExpr(mlir::Location loc, mlir::Region ®ion,
+ bool isOuterMaskExpr);
/// Generate the none elemental part. Must be called outside of the
/// loops created for the WHERE construct.
@@ -81,14 +82,17 @@ struct MaskedArrayExpr {
mlir::Location loc;
mlir::Region ®ion;
- /// Was generateNoneElementalPart called?
- bool noneElementalPartWasGenerated = false;
/// Set of operations that form the elemental parts of the
/// expression evaluation. These are the hlfir.elemental and
/// hlfir.elemental_addr that form the elemental tree producing
/// the expression value. hlfir.elemental that produce values
/// used inside transformational operations are not part of this set.
llvm::SmallSet<mlir::Operation *, 4> elementalParts{};
+ /// Was generateNoneElementalPart called?
+ bool noneElementalPartWasGenerated = false;
+ /// Is this expression the mask expression of the outer where statement?
+ /// It is special because its evaluation is not masked by anything yet.
+ bool isOuterMaskExpr = false;
};
} // namespace
@@ -202,7 +206,7 @@ class OrderedAssignmentRewriter {
/// This method returns the scalar element (that may have been previously
/// saved) for the current indices inside the where loop.
mlir::Value generateMaskedEntity(mlir::Location loc, mlir::Region ®ion) {
- MaskedArrayExpr maskedExpr(loc, region);
+ MaskedArrayExpr maskedExpr(loc, region, /*isOuterMaskExpr=*/!whereLoopNest);
return generateMaskedEntity(maskedExpr);
}
mlir::Value generateMaskedEntity(MaskedArrayExpr &maskedExpr);
@@ -524,7 +528,8 @@ void OrderedAssignmentRewriter::pre(hlfir::WhereOp whereOp) {
return;
}
// The mask was not evaluated yet or can be safely re-evaluated.
- MaskedArrayExpr mask(loc, whereOp.getMaskRegion());
+ MaskedArrayExpr mask(loc, whereOp.getMaskRegion(),
+ /*isOuterMaskExpr=*/true);
mask.generateNoneElementalPart(builder, mapper);
mlir::Value shape = mask.generateShape(builder, mapper);
whereLoopNest = hlfir::genLoopNest(loc, builder, shape);
@@ -628,6 +633,13 @@ OrderedAssignmentRewriter::getIfSaved(mlir::Region ®ion) {
return std::nullopt;
}
+static hlfir::YieldOp getYield(mlir::Region ®ion) {
+ auto yield = mlir::dyn_cast_or_null<hlfir::YieldOp>(
+ region.back().getOperations().back());
+ assert(yield && "region computing entities must end with a YieldOp");
+ return yield;
+}
+
OrderedAssignmentRewriter::ValueAndCleanUp
OrderedAssignmentRewriter::generateYieldedEntity(
mlir::Region ®ion, std::optional<mlir::Type> castToType) {
@@ -644,9 +656,7 @@ OrderedAssignmentRewriter::generateYieldedEntity(
}
assert(region.hasOneBlock() && "region must contain one block");
- auto oldYield = mlir::dyn_cast_or_null<hlfir::YieldOp>(
- region.back().getOperations().back());
- assert(oldYield && "region computing entities must end with a YieldOp");
+ auto oldYield = getYield(region);
mlir::Block::OpListType &ops = region.back().getOperations();
// Inside Forall, scalars that do not depend on forall indices can be hoisted
@@ -887,8 +897,9 @@ gatherElementalTree(hlfir::ElementalOpInterface elemental,
}
}
-MaskedArrayExpr::MaskedArrayExpr(mlir::Location loc, mlir::Region ®ion)
- : loc{loc}, region{region} {
+MaskedArrayExpr::MaskedArrayExpr(mlir::Location loc, mlir::Region ®ion,
+ bool isOuterMaskExpr)
+ : loc{loc}, region{region}, isOuterMaskExpr{isOuterMaskExpr} {
mlir::Operation &terminator = region.back().back();
if (auto elementalAddr =
mlir::dyn_cast<hlfir::ElementalOpInterface>(terminator)) {
@@ -907,13 +918,36 @@ void MaskedArrayExpr::generateNoneElementalPart(fir::FirOpBuilder &builder,
mlir::IRMapping &mapper) {
assert(!noneElementalPartWasGenerated &&
"none elemental parts already generated");
- // Clone all operations, except the elemental and the final yield.
- mlir::Block::OpListType &ops = region.back().getOperations();
- assert(!ops.empty() && "yield block cannot be empty");
- auto end = ops.end();
- for (auto opIt = ops.begin(); std::next(opIt) != end; ++opIt)
- if (!elementalParts.contains(&*opIt))
- (void)builder.clone(*opIt, mapper);
+ if (isOuterMaskExpr) {
+ // The outer mask expression is actually not masked, it is dealt as
+ // such so that its elemental part, if any, can be inlined in the WHERE
+ // loops. But all of the operations outside of hlfir.elemental/
+ // hlfir.elemental_addr must be emitted now because their value may be
+ // required to deduce the mask shape and the WHERE loop bounds.
+ for (mlir::Operation &op : region.back().without_terminator())
+ if (!elementalParts.contains(&op))
+ (void)builder.clone(op, mapper);
+ } else {
+ // For actual masked expressions, Fortran requires elemental expressions,
+ // even the scalar ones that are no encoded with hlfir.elemental, to be
+ // evaluated only when the mask is true. Blindly hoisting all scalar SSA
+ // tree could be wrong if the scalar computation has side effects and
+ // would never have been evaluated (e.g. division by zero) if the mask
+ // is fully false. See F'2023 10.2.3.2 point 10.
+ // Clone only the bodies of all hlfir.exactly_once operations, which contain
+ // the evaluation of sub-expression tree whose root was a non elemental
+ // function call at the Fortran level (the call itself may have been inlined
+ // since). These must be evaluated only once as per F'2023 10.2.3.2 point 9.
+ for (mlir::Operation &op : region.back().without_terminator())
+ if (auto exactlyOnce = mlir::dyn_cast<hlfir::ExactlyOnceOp>(op)) {
+ for (mlir::Operation &subOp :
+ exactlyOnce.getBody().back().without_terminator())
+ (void)builder.clone(subOp, mapper);
+ mlir::Value oldYield = getYield(exactlyOnce.getBody()).getEntity();
+ auto newYield = mapper.lookupOrDefault(oldYield);
+ mapper.map(exactlyOnce.getResult(), newYield);
+ }
+ }
noneElementalPartWasGenerated = true;
}
@@ -942,6 +976,15 @@ MaskedArrayExpr::generateElementalParts(fir::FirOpBuilder &builder,
mlir::IRMapping &mapper) {
assert(noneElementalPartWasGenerated &&
"non elemental part must have been generated");
+ if (!isOuterMaskExpr) {
+ // Clone all operations that are not hlfir.exactly_once and that are not
+ // hlfir.elemental/hlfir.elemental_addr.
+ for (mlir::Operation &op : region.back().without_terminator())
+ if (!mlir::isa<hlfir::ExactlyOnceOp>(op) && !elementalParts.contains(&op))
+ (void)builder.clone(op, mapper);
+ // For the outer mask, this was already done outside of the loop.
+ }
+ // Clone and "index" bodies of hlfir.elemental/hlfir.elemental_addr.
mlir::Operation &terminator = region.back().back();
hlfir::ElementalOpInterface elemental =
mlir::dyn_cast<hlfir::ElementalAddrOp>(terminator);
@@ -968,6 +1011,22 @@ MaskedArrayExpr::generateElementalParts(fir::FirOpBuilder &builder,
void MaskedArrayExpr::generateNoneElementalCleanupIfAny(
fir::FirOpBuilder &builder, mlir::IRMapping &mapper) {
+ if (!isOuterMaskExpr) {
+ // Clone clean-ups of hlfir.exactly_once operations (in reverse order
+ // to properly deal with stack restores).
+ for (mlir::Operation &op :
+ llvm::reverse(region.back().without_terminator()))
+ if (auto exactlyOnce = mlir::dyn_cast<hlfir::ExactlyOnceOp>(op)) {
+ mlir::Region &cleanupRegion =
+ getYield(exactlyOnce.getBody()).getCleanup();
+ if (!cleanupRegion.empty())
+ for (mlir::Operation &cleanupOp :
+ cleanupRegion.front().without_terminator())
+ (void)builder.clone(cleanupOp, mapper);
+ }
+ }
+ // Clone the clean-ups from the region itself, except for the destroy
+ // of the hlfir.elemental that have been inlined.
mlir::Operation &terminator = region.back().back();
mlir::Region *cleanupRegion = nullptr;
if (auto elementalAddr = mlir::dyn_cast<hlfir::ElementalAddrOp>(terminator)) {
diff --git a/flang/test/HLFIR/order_assignments/impure-where.fir b/flang/test/HLFIR/order_assignments/impure-where.fir
index 9399ea83d1822..011a486b2baf7 100644
--- a/flang/test/HLFIR/order_assignments/impure-where.fir
+++ b/flang/test/HLFIR/order_assignments/impure-where.fir
@@ -13,10 +13,13 @@ func.func @test_elsewhere_impure_mask(%x: !fir.ref<!fir.array<10xi32>>, %y: !fir
hlfir.yield %mask : !fir.ref<!fir.array<10x!fir.logical<4>>>
} do {
hlfir.elsewhere mask {
- %mask2 = fir.call @impure() : () -> !fir.heap<!fir.array<10x!fir.logical<4>>>
- hlfir.yield %mask2 : !fir.heap<!fir.array<10x!fir.logical<4>>> cleanup {
- fir.freemem %mask2 : !fir.heap<!fir.array<10x!fir.logical<4>>>
+ %mask2 = hlfir.exactly_once : !fir.heap<!fir.array<10x!fir.logical<4>>> {
+ %imp = fir.call @impure() : () -> !fir.heap<!fir.array<10x!fir.logical<4>>>
+ hlfir.yield %imp : !fir.heap<!fir.array<10x!fir.logical<4>>> cleanup {
+ fir.freemem %imp : !fir.heap<!fir.array<10x!fir.logical<4>>>
+ }
}
+ hlfir.yield %mask2 : !fir.heap<!fir.array<10x!fir.logical<4>>>
} do {
hlfir.region_assign {
hlfir.yield %y : !fir.ref<!fir.array<10xi32>>
diff --git a/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir b/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir
index 66ff55558ea67..0724d019537c0 100644
--- a/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir
+++ b/flang/test/HLFIR/order_assignments/inlined-stack-temp.fir
@@ -282,7 +282,6 @@ func.func @test_where_rhs_save(%x: !fir.ref<!fir.array<10xi32>>, %mask: !fir.ref
// CHECK: %[[VAL_7:.*]] = arith.constant 10 : index
// CHECK: %[[VAL_8:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
// CHECK: %[[VAL_9:.*]] = arith.constant 1 : index
-// CHECK: %[[VAL_...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/91395
More information about the flang-commits
mailing list