This is an archive of the discontinued LLVM Phabricator instance.

Differential D149950

[flang][hlfir] Lower WHERE to HLFIR
ClosedPublic

Authored by jeanPerier on May 5 2023, 5:05 AM.

Details

Reviewers
vzakhari
clementval
tblah
Commits
rG54c88fc9dfa5: [flang][hlfir] Lower WHERE to HLFIR
Summary

Lower WHERE to the newly added hlfir.where and hlfir.elsewhere
operations.

Depends on D149878

Diff Detail

Event Timeline

jeanPerier created this revision.May 5 2023, 5:05 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 5 2023, 5:05 AM
Herald added subscribers: sunshaoce, mehdi_amini, jdoerfert. · View Herald Transcript
jeanPerier requested review of this revision.May 5 2023, 5:05 AM
Harbormaster completed remote builds in B230208: Diff 519810.May 5 2023, 5:17 AM
tblah accepted this revision.May 5 2023, 6:06 AM

Looks great to me. These forall/where patches are excellent

This revision is now accepted and ready to land.May 5 2023, 6:06 AM
jeanPerier added a child revision: D149962: [flang][hlfir] Lower left-hand side vector subscripts to HLFIR.May 5 2023, 8:03 AM
Closed by commit rG54c88fc9dfa5: [flang][hlfir] Lower WHERE to HLFIR (authored by jeanPerier). · Explain WhyMay 9 2023, 12:22 AM
This revision was automatically updated to reflect the committed changes.
jeanPerier added a commit: rG54c88fc9dfa5: [flang][hlfir] Lower WHERE to HLFIR.

Revision Contents

PathSize
flang/
lib/
Lower/
108 lines
test/
Lower/
HLFIR/
170 lines

Diff 520609

flang/lib/Lower/Bridge.cpp

Show First 20 Lines • Show All 3,148 Lines • ▼ Show 20 Lines#endif
void genDataAssignment( void genDataAssignment(
const Fortran::evaluate::Assignment &assign, const Fortran::evaluate::Assignment &assign,
const Fortran::evaluate::ProcedureRef *userDefinedAssignment) { const Fortran::evaluate::ProcedureRef *userDefinedAssignment) {
mlir::Location loc = getCurrentLocation(); mlir::Location loc = getCurrentLocation();
fir::FirOpBuilder &builder = getFirOpBuilder(); fir::FirOpBuilder &builder = getFirOpBuilder();
// Gather some information about the assignment that will impact how it is // Gather some information about the assignment that will impact how it is
// lowered. // lowered.
const bool isWholeAllocatableAssignment = const bool isWholeAllocatableAssignment =
!userDefinedAssignment && !userDefinedAssignment && !isInsideHlfirWhere() &&
Fortran::lower::isWholeAllocatable(assign.lhs); Fortran::lower::isWholeAllocatable(assign.lhs);
std::optional<Fortran::evaluate::DynamicType> lhsType = std::optional<Fortran::evaluate::DynamicType> lhsType =
assign.lhs.GetType(); assign.lhs.GetType();
const bool keepLhsLengthInAllocatableAssignment = const bool keepLhsLengthInAllocatableAssignment =
isWholeAllocatableAssignment && lhsType.has_value() && isWholeAllocatableAssignment && lhsType.has_value() &&
lhsType->category() == Fortran::common::TypeCategory::Character && lhsType->category() == Fortran::common::TypeCategory::Character &&
!lhsType->HasDeferredTypeParameter(); !lhsType->HasDeferredTypeParameter();
const bool lhsHasVectorSubscripts = const bool lhsHasVectorSubscripts =
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines void genDataAssignment(
builder.setInsertionPointAfter(regionAssignOp); builder.setInsertionPointAfter(regionAssignOp);
} }
/// Shared for both assignments and pointer assignments. /// Shared for both assignments and pointer assignments.
void genAssignment(const Fortran::evaluate::Assignment &assign) { void genAssignment(const Fortran::evaluate::Assignment &assign) {
mlir::Location loc = toLocation(); mlir::Location loc = toLocation();
if (lowerToHighLevelFIR()) { if (lowerToHighLevelFIR()) {
if (!implicitIterSpace.empty())
TODO(loc, "HLFIR assignment inside WHERE");
std::visit( std::visit(
Fortran::common::visitors{ Fortran::common::visitors{
[&](const Fortran::evaluate::Assignment::Intrinsic &) { [&](const Fortran::evaluate::Assignment::Intrinsic &) {
genDataAssignment(assign, /*userDefinedAssignment=*/nullptr); genDataAssignment(assign, /*userDefinedAssignment=*/nullptr);
}, },
[&](const Fortran::evaluate::ProcedureRef &procRef) { [&](const Fortran::evaluate::ProcedureRef &procRef) {
genDataAssignment(assign, /*userDefinedAssignment=*/&procRef); genDataAssignment(assign, /*userDefinedAssignment=*/&procRef);
}, },
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines std::visit(
return genPointerAssignment(loc, assign, boundExprs); return genPointerAssignment(loc, assign, boundExprs);
}, },
}, },
assign.u); assign.u);
if (explicitIterationSpace()) if (explicitIterationSpace())
Fortran::lower::createArrayMergeStores(*this, explicitIterSpace); Fortran::lower::createArrayMergeStores(*this, explicitIterSpace);
} }
bool isInsideHlfirForallOrWhere() const { // Is the insertion point of the builder directly or indirectly set
// inside any operation of type "Op"?
template <typename... Op>
bool isInsideOp() const {
mlir::Block *block = builder->getInsertionBlock(); mlir::Block *block = builder->getInsertionBlock();
mlir::Operation *op = block ? block->getParentOp() : nullptr; mlir::Operation *op = block ? block->getParentOp() : nullptr;
while (op) { while (op) {
if (mlir::isa<hlfir::ForallOp, hlfir::WhereOp>(op)) if (mlir::isa<Op...>(op))
return true; return true;
op = op->getParentOp(); op = op->getParentOp();
} }
return false; return false;
} }
bool isInsideHlfirForallOrWhere() const {
return isInsideOp<hlfir::ForallOp, hlfir::WhereOp>();
}
bool isInsideHlfirWhere() const { return isInsideOp<hlfir::WhereOp>(); }
void genFIR(const Fortran::parser::WhereConstruct &c) { void genFIR(const Fortran::parser::WhereConstruct &c) {
mlir::Location loc = getCurrentLocation();
hlfir::WhereOp whereOp;
if (!lowerToHighLevelFIR()) {
implicitIterSpace.growStack(); implicitIterSpace.growStack();
} else {
whereOp = builder->create<hlfir::WhereOp>(loc);
builder->createBlock(&whereOp.getMaskRegion());
}
// Lower the where mask. For HLFIR, this is done in the hlfir.where mask
// region.
genNestedStatement( genNestedStatement(
std::get< std::get<
Fortran::parser::Statement<Fortran::parser::WhereConstructStmt>>( Fortran::parser::Statement<Fortran::parser::WhereConstructStmt>>(
c.t)); c.t));
// Lower WHERE body. For HLFIR, this is done in the hlfir.where body
// region.
if (whereOp)
builder->createBlock(&whereOp.getBody());
for (const auto &body : for (const auto &body :
std::get<std::list<Fortran::parser::WhereBodyConstruct>>(c.t)) std::get<std::list<Fortran::parser::WhereBodyConstruct>>(c.t))
genFIR(body); genFIR(body);
for (const auto &e : for (const auto &e :
std::get<std::list<Fortran::parser::WhereConstruct::MaskedElsewhere>>( std::get<std::list<Fortran::parser::WhereConstruct::MaskedElsewhere>>(
c.t)) c.t))
genFIR(e); genFIR(e);
if (const auto &e = if (const auto &e =
std::get<std::optional<Fortran::parser::WhereConstruct::Elsewhere>>( std::get<std::optional<Fortran::parser::WhereConstruct::Elsewhere>>(
c.t); c.t);
e.has_value()) e.has_value())
genFIR(*e); genFIR(*e);
genNestedStatement( genNestedStatement(
std::get<Fortran::parser::Statement<Fortran::parser::EndWhereStmt>>( std::get<Fortran::parser::Statement<Fortran::parser::EndWhereStmt>>(
c.t)); c.t));
if (whereOp) {
// For HLFIR, create fir.end terminator in the last hlfir.elsewhere, or
// in the hlfir.where if it had no elsewhere.
builder->create<fir::FirEndOp>(loc);
builder->setInsertionPointAfter(whereOp);
}
} }
void genFIR(const Fortran::parser::WhereBodyConstruct &body) { void genFIR(const Fortran::parser::WhereBodyConstruct &body) {
std::visit( std::visit(
Fortran::common::visitors{ Fortran::common::visitors{
[&](const Fortran::parser::Statement< [&](const Fortran::parser::Statement<
Fortran::parser::AssignmentStmt> &stmt) { Fortran::parser::AssignmentStmt> &stmt) {
genNestedStatement(stmt); genNestedStatement(stmt);
}, },
[&](const Fortran::parser::Statement<Fortran::parser::WhereStmt> [&](const Fortran::parser::Statement<Fortran::parser::WhereStmt>
&stmt) { genNestedStatement(stmt); }, &stmt) { genNestedStatement(stmt); },
[&](const Fortran::common::Indirection< [&](const Fortran::common::Indirection<
Fortran::parser::WhereConstruct> &c) { genFIR(c.value()); }, Fortran::parser::WhereConstruct> &c) { genFIR(c.value()); },
}, },
body.u); body.u);
} }
/// Lower a Where or Elsewhere mask into an hlfir mask region.
void lowerWhereMaskToHlfir(mlir::Location loc,
const Fortran::semantics::SomeExpr *maskExpr) {
assert(maskExpr && "mask semantic analysis failed");
Fortran::lower::StatementContext maskContext;
hlfir::Entity mask = Fortran::lower::convertExprToHLFIR(
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);
}
void genFIR(const Fortran::parser::WhereConstructStmt &stmt) { void genFIR(const Fortran::parser::WhereConstructStmt &stmt) {
implicitIterSpace.append(Fortran::semantics::GetExpr( const Fortran::semantics::SomeExpr *maskExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::LogicalExpr>(stmt.t))); std::get<Fortran::parser::LogicalExpr>(stmt.t));
if (lowerToHighLevelFIR())
lowerWhereMaskToHlfir(getCurrentLocation(), maskExpr);
else
implicitIterSpace.append(maskExpr);
} }
void genFIR(const Fortran::parser::WhereConstruct::MaskedElsewhere &ew) { void genFIR(const Fortran::parser::WhereConstruct::MaskedElsewhere &ew) {
mlir::Location loc = getCurrentLocation();
hlfir::ElseWhereOp elsewhereOp;
if (lowerToHighLevelFIR()) {
elsewhereOp = builder->create<hlfir::ElseWhereOp>(loc);
// Lower mask in the mask region.
builder->createBlock(&elsewhereOp.getMaskRegion());
}
genNestedStatement( genNestedStatement(
std::get< std::get<
Fortran::parser::Statement<Fortran::parser::MaskedElsewhereStmt>>( Fortran::parser::Statement<Fortran::parser::MaskedElsewhereStmt>>(
ew.t)); ew.t));
// For HLFIR, lower the body in the hlfir.elsewhere body region.
if (elsewhereOp)
builder->createBlock(&elsewhereOp.getBody());
for (const auto &body : for (const auto &body :
std::get<std::list<Fortran::parser::WhereBodyConstruct>>(ew.t)) std::get<std::list<Fortran::parser::WhereBodyConstruct>>(ew.t))
genFIR(body); genFIR(body);
} }
void genFIR(const Fortran::parser::MaskedElsewhereStmt &stmt) { void genFIR(const Fortran::parser::MaskedElsewhereStmt &stmt) {
implicitIterSpace.append(Fortran::semantics::GetExpr( const auto *maskExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::LogicalExpr>(stmt.t))); std::get<Fortran::parser::LogicalExpr>(stmt.t));
if (lowerToHighLevelFIR())
lowerWhereMaskToHlfir(getCurrentLocation(), maskExpr);
else
implicitIterSpace.append(maskExpr);
} }
void genFIR(const Fortran::parser::WhereConstruct::Elsewhere &ew) { void genFIR(const Fortran::parser::WhereConstruct::Elsewhere &ew) {
if (lowerToHighLevelFIR()) {
auto elsewhereOp =
builder->create<hlfir::ElseWhereOp>(getCurrentLocation());
builder->createBlock(&elsewhereOp.getBody());
}
genNestedStatement( genNestedStatement(
std::get<Fortran::parser::Statement<Fortran::parser::ElsewhereStmt>>( std::get<Fortran::parser::Statement<Fortran::parser::ElsewhereStmt>>(
ew.t)); ew.t));
for (const auto &body : for (const auto &body :
std::get<std::list<Fortran::parser::WhereBodyConstruct>>(ew.t)) std::get<std::list<Fortran::parser::WhereBodyConstruct>>(ew.t))
genFIR(body); genFIR(body);
} }
void genFIR(const Fortran::parser::ElsewhereStmt &stmt) { void genFIR(const Fortran::parser::ElsewhereStmt &stmt) {
if (!lowerToHighLevelFIR())
implicitIterSpace.append(nullptr); implicitIterSpace.append(nullptr);
} }
void genFIR(const Fortran::parser::EndWhereStmt &) { void genFIR(const Fortran::parser::EndWhereStmt &) {
if (!lowerToHighLevelFIR())
implicitIterSpace.shrinkStack(); implicitIterSpace.shrinkStack();
} }
void genFIR(const Fortran::parser::WhereStmt &stmt) { void genFIR(const Fortran::parser::WhereStmt &stmt) {
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
const auto &assign = std::get<Fortran::parser::AssignmentStmt>(stmt.t); const auto &assign = std::get<Fortran::parser::AssignmentStmt>(stmt.t);
const auto *mask = Fortran::semantics::GetExpr(
std::get<Fortran::parser::LogicalExpr>(stmt.t));
if (lowerToHighLevelFIR()) {
mlir::Location loc = getCurrentLocation();
auto whereOp = builder->create<hlfir::WhereOp>(loc);
builder->createBlock(&whereOp.getMaskRegion());
lowerWhereMaskToHlfir(loc, mask);
builder->createBlock(&whereOp.getBody());
genAssignment(*assign.typedAssignment->v);
builder->create<fir::FirEndOp>(loc);
builder->setInsertionPointAfter(whereOp);
return;
}
implicitIterSpace.growStack(); implicitIterSpace.growStack();
implicitIterSpace.append(Fortran::semantics::GetExpr( implicitIterSpace.append(mask);
std::get<Fortran::parser::LogicalExpr>(stmt.t)));
genAssignment(*assign.typedAssignment->v); genAssignment(*assign.typedAssignment->v);
implicitIterSpace.shrinkStack(); implicitIterSpace.shrinkStack();
} }
void genFIR(const Fortran::parser::PointerAssignmentStmt &stmt) { void genFIR(const Fortran::parser::PointerAssignmentStmt &stmt) {
genAssignment(*stmt.typedAssignment->v); genAssignment(*stmt.typedAssignment->v);
} }
▲ Show 20 Lines • Show All 886 Lines • Show Last 20 Lines

flang/test/Lower/HLFIR/where.f90

  • This file was added.
! Test lowering of WHERE construct and statements to HLFIR.
! RUN: bbc --hlfir -emit-fir -o - %s | FileCheck %s
module where_defs
logical :: mask(10)
real :: x(10), y(10)
real, allocatable :: a(:), b(:)
interface
function return_temporary_mask()
logical, allocatable :: return_temporary_mask(:)
end function
function return_temporary_array()
real, allocatable :: return_temporary_array(:)
end function
end interface
end module
subroutine simple_where()
use where_defs, only: mask, x, y
where (mask) x = y
end subroutine
! CHECK-LABEL: func.func @_QPsimple_where() {
! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare {{.*}}Emask
! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare {{.*}}Ex
! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare {{.*}}Ey
! CHECK: hlfir.where {
! CHECK: hlfir.yield %[[VAL_3]]#0 : !fir.ref<!fir.array<10x!fir.logical<4>>>
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_7]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: }
! CHECK: return
! CHECK:}
subroutine where_construct()
use where_defs
where (mask)
x = y
a = b
end where
end subroutine
! CHECK-LABEL: func.func @_QPwhere_construct() {
! CHECK: %[[VAL_1:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QMwhere_defsEa"}
! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %{{.*}} {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QMwhere_defsEb"}
! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare {{.*}}Emask
! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare {{.*}}Ex
! CHECK: %[[VAL_15:.*]]:2 = hlfir.declare {{.*}}Ey
! CHECK: hlfir.where {
! CHECK: hlfir.yield %[[VAL_7]]#0 : !fir.ref<!fir.array<10x!fir.logical<4>>>
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_15]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: hlfir.region_assign {
! CHECK: %[[VAL_16:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
! CHECK: hlfir.yield %[[VAL_16]] : !fir.box<!fir.heap<!fir.array<?xf32>>>
! CHECK: } to {
! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
! CHECK: hlfir.yield %[[VAL_17]] : !fir.box<!fir.heap<!fir.array<?xf32>>>
! CHECK: }
! CHECK: }
! CHECK: return
! CHECK:}
subroutine where_cleanup()
use where_defs, only: x, return_temporary_mask, return_temporary_array
where (return_temporary_mask()) x = return_temporary_array()
end subroutine
! CHECK-LABEL: func.func @_QPwhere_cleanup() {
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {bindc_name = ".result"}
! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>> {bindc_name = ".result"}
! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare {{.*}}Ex
! CHECK: hlfir.where {
! CHECK: %[[VAL_6:.*]] = fir.call @_QPreturn_temporary_mask() fastmath<contract> : () -> !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>
! CHECK: fir.save_result %[[VAL_6]] to %[[VAL_1]] : !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_1]] {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>)
! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_7]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>>>
! CHECK: hlfir.yield %[[VAL_8]] : !fir.box<!fir.heap<!fir.array<?x!fir.logical<4>>>> cleanup {
! CHECK: fir.freemem
! CHECK: }
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: %[[VAL_14:.*]] = fir.call @_QPreturn_temporary_array() fastmath<contract> : () -> !fir.box<!fir.heap<!fir.array<?xf32>>>
! CHECK: fir.save_result %[[VAL_14]] to %[[VAL_0]] : !fir.box<!fir.heap<!fir.array<?xf32>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
! CHECK: %[[VAL_15:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>, !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>)
! CHECK: %[[VAL_16:.*]] = fir.load %[[VAL_15]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
! CHECK: hlfir.yield %[[VAL_16]] : !fir.box<!fir.heap<!fir.array<?xf32>>> cleanup {
! CHECK: fir.freemem
! CHECK: }
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_5]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: }
subroutine simple_elsewhere()
use where_defs
where (mask)
x = y
elsewhere
y = x
end where
end subroutine
! CHECK-LABEL: func.func @_QPsimple_elsewhere() {
! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare {{.*}}Emask
! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare {{.*}}Ex
! CHECK: %[[VAL_15:.*]]:2 = hlfir.declare {{.*}}Ey
! CHECK: hlfir.where {
! CHECK: hlfir.yield %[[VAL_7]]#0 : !fir.ref<!fir.array<10x!fir.logical<4>>>
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_15]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: hlfir.elsewhere do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_15]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: }
! CHECK: }
subroutine elsewhere_2(mask2)
use where_defs, only : mask, x, y
logical :: mask2(:)
where (mask)
x = y
elsewhere(mask2)
y = x
elsewhere
x = foo()
end where
end subroutine
! CHECK-LABEL: func.func @_QPelsewhere_2(
! CHECK: %[[VAL_5:.*]]:2 = hlfir.declare {{.*}}Emask
! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare {{.*}}Emask2
! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare {{.*}}Ex
! CHECK: %[[VAL_15:.*]]:2 = hlfir.declare {{.*}}Ey
! CHECK: hlfir.where {
! CHECK: hlfir.yield %[[VAL_5]]#0 : !fir.ref<!fir.array<10x!fir.logical<4>>>
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_15]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: hlfir.elsewhere mask {
! CHECK: hlfir.yield %[[VAL_6]]#0 : !fir.box<!fir.array<?x!fir.logical<4>>>
! CHECK: } do {
! CHECK: hlfir.region_assign {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_15]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: hlfir.elsewhere do {
! CHECK: hlfir.region_assign {
! CHECK: %[[VAL_16:.*]] = fir.call @_QPfoo() fastmath<contract> : () -> f32
! CHECK: hlfir.yield %[[VAL_16]] : f32
! CHECK: } to {
! CHECK: hlfir.yield %[[VAL_11]]#0 : !fir.ref<!fir.array<10xf32>>
! CHECK: }
! CHECK: }
! CHECK: }
! CHECK: }