This is an archive of the discontinued LLVM Phabricator instance.

Differential D125336

[flang] Upstream fix for performance issue
ClosedPublic

Authored by schweitz on May 10 2022, 1:32 PM.

Details

Reviewers
jeanPerier
vdonaldson
PeteSteinfeld
Commits
rG6822ed035f18: Fixes a performance problem with lowering of forall loops and creating
Summary

Lowering of assignments in forall constructs could result in too many temporaries and copies. These changes eliminate this duplication.

Diff Detail

Event Timeline

schweitz created this revision.May 10 2022, 1:32 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptMay 10 2022, 1:32 PM
schweitz requested review of this revision.May 10 2022, 1:32 PM
Herald added a subscriber: jdoerfert. · View Herald TranscriptMay 10 2022, 1:32 PM
schweitz updated this revision to Diff 428487.May 10 2022, 1:34 PM
Herald added a subscriber: mehdi_amini. · View Herald TranscriptMay 10 2022, 1:34 PM
schweitz added reviewers: jeanPerier, vdonaldson, PeteSteinfeld.May 10 2022, 1:37 PM
PeteSteinfeld accepted this revision.May 10 2022, 2:09 PM

All builds and tests correctly and looks good.

This revision is now accepted and ready to land.May 10 2022, 2:09 PM
Harbormaster completed remote builds in B163777: Diff 428487.May 10 2022, 2:44 PM
jeanPerier accepted this revision.May 11 2022, 1:13 AM

clang-format should be run on lib/Lower/ConvertExpr.cpp, otherwise LGTM.

schweitz updated this revision to Diff 428671.May 11 2022, 8:23 AM

Fixes clang-format issues on the entire file.

schweitz updated this revision to Diff 428676.May 11 2022, 8:29 AM
Harbormaster completed remote builds in B163915: Diff 428676.May 11 2022, 11:13 AM
Closed by commit rG6822ed035f18: Fixes a performance problem with lowering of forall loops and creating (authored by schweitz). · Explain WhyMay 12 2022, 8:12 AM
This revision was automatically updated to reflect the committed changes.
schweitz added a commit: rG6822ed035f18: Fixes a performance problem with lowering of forall loops and creating.

Revision Contents

PathSize
flang/
lib/
Lower/
34 lines
test/
Lower/
forall/
284 lines
12 lines
2 lines
2 lines
4 lines
2 lines
2 lines
102 lines

Diff 428676

flang/lib/Lower/ConvertExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,780 Lines • ▼ Show 20 Lines createScalarTempForArgThatMayBeAbsent(ExtValue actualArg,
mlir::Type type = fir::unwrapRefType(fir::getBase(actualArg).getType()); mlir::Type type = fir::unwrapRefType(fir::getBase(actualArg).getType());
if (fir::isDerivedWithLenParameters(actualArg)) if (fir::isDerivedWithLenParameters(actualArg))
TODO(loc, "parametrized derived type optional scalar argument copy-in"); TODO(loc, "parametrized derived type optional scalar argument copy-in");
if (const fir::CharBoxValue *charBox = actualArg.getCharBox()) { if (const fir::CharBoxValue *charBox = actualArg.getCharBox()) {
mlir::Value len = charBox->getLen(); mlir::Value len = charBox->getLen();
mlir::Value zero = builder.createIntegerConstant(loc, len.getType(), 0); mlir::Value zero = builder.createIntegerConstant(loc, len.getType(), 0);
len = builder.create<mlir::arith::SelectOp>(loc, isPresent, len, zero); len = builder.create<mlir::arith::SelectOp>(loc, isPresent, len, zero);
mlir::Value temp = builder.createTemporary( mlir::Value temp = builder.createTemporary(
loc, type, /*name=*/{}, /*shape=*/{}, mlir::ValueRange{len}, loc, type, /*name=*/{},
/*shape=*/{}, mlir::ValueRange{len},
llvm::ArrayRef<mlir::NamedAttribute>{ llvm::ArrayRef<mlir::NamedAttribute>{
Fortran::lower::getAdaptToByRefAttr(builder)}); Fortran::lower::getAdaptToByRefAttr(builder)});
return fir::CharBoxValue{temp, len}; return fir::CharBoxValue{temp, len};
} }
assert((fir::isa_trivial(type) || type.isa<fir::RecordType>()) && assert((fir::isa_trivial(type) || type.isa<fir::RecordType>()) &&
"must be simple scalar"); "must be simple scalar");
return builder.createTemporary( return builder.createTemporary(
loc, type, loc, type,
▲ Show 20 Lines • Show All 1,309 Lines • ▼ Show 20 Linesprivate:
/// numeric types are treated as values. /// numeric types are treated as values.
static mlir::Type adjustedArraySubtype(mlir::Type ty, static mlir::Type adjustedArraySubtype(mlir::Type ty,
mlir::ValueRange indices) { mlir::ValueRange indices) {
mlir::Type pathTy = fir::applyPathToType(ty, indices); mlir::Type pathTy = fir::applyPathToType(ty, indices);
assert(pathTy && "indices failed to apply to type"); assert(pathTy && "indices failed to apply to type");
return adjustedArrayElementType(pathTy); return adjustedArrayElementType(pathTy);
} }
/// Lower rhs of an array expression.
ExtValue lowerArrayExpression(const Fortran::lower::SomeExpr &exp) { ExtValue lowerArrayExpression(const Fortran::lower::SomeExpr &exp) {
mlir::Type resTy = converter.genType(exp); mlir::Type resTy = converter.genType(exp);
return std::visit( return std::visit(
[&](const auto &e) { return lowerArrayExpression(genarr(e), resTy); }, [&](const auto &e) { return lowerArrayExpression(genarr(e), resTy); },
exp.u); exp.u);
} }
ExtValue lowerArrayExpression(const ExtValue &exv) { ExtValue lowerArrayExpression(const ExtValue &exv) {
assert(!explicitSpace); assert(!explicitSpace);
▲ Show 20 Lines • Show All 197 Lines • ▼ Show 20 Lines CC genMaskAccess(mlir::Value tmp, mlir::Value shape) {
return [=, builder = &converter.getFirOpBuilder()](IterSpace iters) { return [=, builder = &converter.getFirOpBuilder()](IterSpace iters) {
mlir::Type arrTy = fir::dyn_cast_ptrOrBoxEleTy(tmp.getType()); mlir::Type arrTy = fir::dyn_cast_ptrOrBoxEleTy(tmp.getType());
auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy(); auto eleTy = arrTy.cast<fir::SequenceType>().getEleTy();
mlir::Type eleRefTy = builder->getRefType(eleTy); mlir::Type eleRefTy = builder->getRefType(eleTy);
mlir::IntegerType i1Ty = builder->getI1Type(); mlir::IntegerType i1Ty = builder->getI1Type();
// Adjust indices for any shift of the origin of the array. // Adjust indices for any shift of the origin of the array.
llvm::SmallVector<mlir::Value> indices = fir::factory::originateIndices( llvm::SmallVector<mlir::Value> indices = fir::factory::originateIndices(
loc, *builder, tmp.getType(), shape, iters.iterVec()); loc, *builder, tmp.getType(), shape, iters.iterVec());
auto addr = builder->create<fir::ArrayCoorOp>( auto addr =
loc, eleRefTy, tmp, shape, /*slice=*/mlir::Value{}, indices, builder->create<fir::ArrayCoorOp>(loc, eleRefTy, tmp, shape,
/*slice=*/mlir::Value{}, indices,
/*typeParams=*/llvm::None); /*typeParams=*/llvm::None);
auto load = builder->create<fir::LoadOp>(loc, addr); auto load = builder->create<fir::LoadOp>(loc, addr);
return builder->createConvert(loc, i1Ty, load); return builder->createConvert(loc, i1Ty, load);
}; };
} }
/// Construct the incremental instantiations of the ragged array structure. /// Construct the incremental instantiations of the ragged array structure.
/// Rebind the lazy buffer variable, etc. as we go. /// Rebind the lazy buffer variable, etc. as we go.
template <bool withAllocation = false> template <bool withAllocation = false>
▲ Show 20 Lines • Show All 736 Lines • ▼ Show 20 Lines template <typename A, typename = std::enable_if_t<Fortran::common::HasMember<
A, Fortran::evaluate::TypelessExpression>>> A, Fortran::evaluate::TypelessExpression>>>
CC genarr(const A &x) { CC genarr(const A &x) {
return genScalarAndForwardValue(x); return genScalarAndForwardValue(x);
} }
template <typename A> template <typename A>
CC genarr(const Fortran::evaluate::Expr<A> &x) { CC genarr(const Fortran::evaluate::Expr<A> &x) {
LLVM_DEBUG(Fortran::lower::DumpEvaluateExpr::dump(llvm::dbgs(), x)); LLVM_DEBUG(Fortran::lower::DumpEvaluateExpr::dump(llvm::dbgs(), x));
if (isArray(x) || explicitSpaceIsActive() || if (isArray(x) || (explicitSpaceIsActive() && isLeftHandSide()) ||
isElementalProcWithArrayArgs(x)) isElementalProcWithArrayArgs(x))
return std::visit([&](const auto &e) { return genarr(e); }, x.u); return std::visit([&](const auto &e) { return genarr(e); }, x.u);
if (explicitSpaceIsActive()) {
assert(!isArray(x) && !isLeftHandSide());
auto cc = std::visit([&](const auto &e) { return genarr(e); }, x.u);
auto result = cc(IterationSpace{});
return [=](IterSpace) { return result; };
}
return genScalarAndForwardValue(x); return genScalarAndForwardValue(x);
} }
// Converting a value of memory bound type requires creating a temp and // Converting a value of memory bound type requires creating a temp and
// copying the value. // copying the value.
static ExtValue convertAdjustedType(fir::FirOpBuilder &builder, static ExtValue convertAdjustedType(fir::FirOpBuilder &builder,
mlir::Location loc, mlir::Type toType, mlir::Location loc, mlir::Type toType,
const ExtValue &exv) { const ExtValue &exv) {
▲ Show 20 Lines • Show All 221 Lines • ▼ Show 20 Lines CC genarr(const Fortran::evaluate::SetLength<KIND> &x) {
return [=](IterSpace iters) -> ExtValue { return [=](IterSpace iters) -> ExtValue {
mlir::Value lhs = fir::getBase(lf(iters)); mlir::Value lhs = fir::getBase(lf(iters));
return fir::CharBoxValue{lhs, rhs}; return fir::CharBoxValue{lhs, rhs};
}; };
} }
template <typename A> template <typename A>
CC genarr(const Fortran::evaluate::Constant<A> &x) { CC genarr(const Fortran::evaluate::Constant<A> &x) {
if (/*explicitSpaceIsActive() &&*/ x.Rank() == 0) if (x.Rank() == 0)
return genScalarAndForwardValue(x); return genScalarAndForwardValue(x);
mlir::Location loc = getLoc(); mlir::Location loc = getLoc();
mlir::IndexType idxTy = builder.getIndexType(); mlir::IndexType idxTy = builder.getIndexType();
mlir::Type arrTy = converter.genType(toEvExpr(x)); mlir::Type arrTy = converter.genType(toEvExpr(x));
std::string globalName = Fortran::lower::mangle::mangleArrayLiteral(x); std::string globalName = Fortran::lower::mangle::mangleArrayLiteral(x);
fir::GlobalOp global = builder.getNamedGlobal(globalName); fir::GlobalOp global = builder.getNamedGlobal(globalName);
if (!global) { if (!global) {
mlir::Type symTy = arrTy; mlir::Type symTy = arrTy;
▲ Show 20 Lines • Show All 1,629 Lines • ▼ Show 20 Lines auto lambda = [=, semant = this->semant](IterSpace iters) mutable {
auto ptrEleTy = fir::PointerType::get(eleTy); auto ptrEleTy = fir::PointerType::get(eleTy);
auto ptrAddr = builder.createConvert(loc, ptrEleTy, addr); auto ptrAddr = builder.createConvert(loc, ptrEleTy, addr);
auto boxTy = fir::BoxType::get(ptrEleTy); auto boxTy = fir::BoxType::get(ptrEleTy);
// FIXME: The typeparams to the load may be different than those of // FIXME: The typeparams to the load may be different than those of
// the subobject. // the subobject.
if (components.hasExtendCoorRef()) if (components.hasExtendCoorRef())
TODO(loc, "need to adjust typeparameter(s) to reflect the final " TODO(loc, "need to adjust typeparameter(s) to reflect the final "
"component"); "component");
mlir::Value embox = builder.create<fir::EmboxOp>( mlir::Value embox =
loc, boxTy, ptrAddr, /*shape=*/mlir::Value{}, builder.create<fir::EmboxOp>(loc, boxTy, ptrAddr,
/*shape=*/mlir::Value{},
/*slice=*/mlir::Value{}, typeParams); /*slice=*/mlir::Value{}, typeParams);
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), embox); return arrayLoadExtValue(builder, loc, load, iters.iterVec(), embox);
} }
} }
auto fetch = builder.create<fir::ArrayFetchOp>( auto fetch = builder.create<fir::ArrayFetchOp>(
loc, eleTy, load, iters.iterVec(), load.getTypeparams()); loc, eleTy, load, iters.iterVec(), load.getTypeparams());
return arrayLoadExtValue(builder, loc, load, iters.iterVec(), fetch); return arrayLoadExtValue(builder, loc, load, iters.iterVec(), fetch);
}; };
return [=](IterSpace iters) mutable { return lambda(pc(iters)); }; return [=](IterSpace iters) mutable { return lambda(pc(iters)); };
▲ Show 20 Lines • Show All 198 Lines • ▼ Show 20 Lines inline bool isProjectedCopyInCopyOut() {
return semant == ConstituentSemantics::ProjectedCopyInCopyOut; return semant == ConstituentSemantics::ProjectedCopyInCopyOut;
} }
// ???: Do we still need this? // ???: Do we still need this?
inline bool isCustomCopyInCopyOut() { inline bool isCustomCopyInCopyOut() {
return semant == ConstituentSemantics::CustomCopyInCopyOut; return semant == ConstituentSemantics::CustomCopyInCopyOut;
} }
/// Are we lowering in a left-hand side context?
inline bool isLeftHandSide() {
return isCopyInCopyOut() || isProjectedCopyInCopyOut() ||
isCustomCopyInCopyOut();
}
/// Array appears in a context where it must be boxed. /// Array appears in a context where it must be boxed.
inline bool isBoxValue() { return semant == ConstituentSemantics::BoxValue; } inline bool isBoxValue() { return semant == ConstituentSemantics::BoxValue; }
/// Array appears in a context where differences in the memory reference can /// Array appears in a context where differences in the memory reference can
/// be observable in the computational results. For example, an array /// be observable in the computational results. For example, an array
/// element is passed to an impure procedure. /// element is passed to an impure procedure.
inline bool isReferentiallyOpaque() { inline bool isReferentiallyOpaque() {
return semant == ConstituentSemantics::RefOpaque; return semant == ConstituentSemantics::RefOpaque;
▲ Show 20 Lines • Show All 393 Lines • Show Last 20 Lines

flang/test/Lower/forall/array-constructor.f90

  • This file was added.
! RUN: bbc -emit-fir %s -o - | FileCheck %s
subroutine ac1(arr,n)
integer :: arr(:), n
forall (i=1:n:2)
arr(i:i+2) = func((/i/))
end forall
contains
pure integer function func(a)
integer, intent(in) :: a(:)
func = a(1)
end function func
end subroutine ac1
! CHECK-LABEL: func @_QPac1(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arr"},
! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
! CHECK: %[[VAL_2:.*]] = fir.alloca index {bindc_name = ".buff.pos"}
! CHECK: %[[VAL_3:.*]] = fir.alloca index {bindc_name = ".buff.size"}
! CHECK: %[[VAL_4:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
! CHECK: %[[VAL_5:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i32) -> index
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i32) -> index
! CHECK: %[[VAL_9:.*]] = arith.constant 2 : i32
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> index
! CHECK: %[[VAL_11:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
! CHECK: %[[VAL_12:.*]] = fir.do_loop %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_8]] step %[[VAL_10]] unordered iter_args(%[[VAL_14:.*]] = %[[VAL_11]]) -> (!fir.array<?xi32>) {
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_13]] : (index) -> i32
! CHECK: fir.store %[[VAL_15]] to %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_17:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i32) -> i64
! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i64) -> index
! CHECK: %[[VAL_20:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i64) -> index
! CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_23:.*]] = arith.constant 2 : i32
! CHECK: %[[VAL_24:.*]] = arith.addi %[[VAL_22]], %[[VAL_23]] : i32
! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i32) -> i64
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i64) -> index
! CHECK: %[[VAL_27:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_26]], %[[VAL_19]] : index
! CHECK: %[[VAL_29:.*]] = arith.addi %[[VAL_28]], %[[VAL_21]] : index
! CHECK: %[[VAL_30:.*]] = arith.divsi %[[VAL_29]], %[[VAL_21]] : index
! CHECK: %[[VAL_31:.*]] = arith.cmpi sgt, %[[VAL_30]], %[[VAL_27]] : index
! CHECK: %[[VAL_32:.*]] = arith.select %[[VAL_31]], %[[VAL_30]], %[[VAL_27]] : index
! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
! CHECK: fir.store %[[VAL_34]] to %[[VAL_2]] : !fir.ref<index>
! CHECK: %[[VAL_35:.*]] = fir.allocmem !fir.array<1xi32>
! CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
! CHECK: fir.store %[[VAL_36]] to %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_37:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_38:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_39:.*]] = fir.zero_bits !fir.ref<!fir.array<1xi32>>
! CHECK: %[[VAL_40:.*]] = fir.coordinate_of %[[VAL_39]], %[[VAL_38]] : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (!fir.ref<i32>) -> index
! CHECK: %[[VAL_42:.*]] = fir.load %[[VAL_2]] : !fir.ref<index>
! CHECK: %[[VAL_43:.*]] = fir.load %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_44:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_45:.*]] = arith.addi %[[VAL_42]], %[[VAL_44]] : index
! CHECK: %[[VAL_46:.*]] = arith.cmpi sle, %[[VAL_43]], %[[VAL_45]] : index
! CHECK: %[[VAL_47:.*]] = fir.if %[[VAL_46]] -> (!fir.heap<!fir.array<1xi32>>) {
! CHECK: %[[VAL_48:.*]] = arith.constant 2 : index
! CHECK: %[[VAL_49:.*]] = arith.muli %[[VAL_45]], %[[VAL_48]] : index
! CHECK: fir.store %[[VAL_49]] to %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_50:.*]] = arith.muli %[[VAL_49]], %[[VAL_41]] : index
! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_35]] : (!fir.heap<!fir.array<1xi32>>) -> !fir.ref<i8>
! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_50]] : (index) -> i64
! CHECK: %[[VAL_53:.*]] = fir.call @realloc(%[[VAL_51]], %[[VAL_52]]) : (!fir.ref<i8>, i64) -> !fir.ref<i8>
! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (!fir.ref<i8>) -> !fir.heap<!fir.array<1xi32>>
! CHECK: fir.result %[[VAL_54]] : !fir.heap<!fir.array<1xi32>>
! CHECK: } else {
! CHECK: fir.result %[[VAL_35]] : !fir.heap<!fir.array<1xi32>>
! CHECK: }
! CHECK: %[[VAL_55:.*]] = fir.coordinate_of %[[VAL_56:.*]], %[[VAL_42]] : (!fir.heap<!fir.array<1xi32>>, index) -> !fir.ref<i32>
! CHECK: fir.store %[[VAL_37]] to %[[VAL_55]] : !fir.ref<i32>
! CHECK: fir.store %[[VAL_45]] to %[[VAL_2]] : !fir.ref<index>
! CHECK: %[[VAL_57:.*]] = fir.load %[[VAL_2]] : !fir.ref<index>
! CHECK: %[[VAL_58:.*]] = fir.shape %[[VAL_57]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_59:.*]] = fir.array_load %[[VAL_56]](%[[VAL_58]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
! CHECK: %[[VAL_60:.*]] = fir.allocmem !fir.array<1xi32>
! CHECK: %[[VAL_61:.*]] = fir.shape %[[VAL_33]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_62:.*]] = fir.array_load %[[VAL_60]](%[[VAL_61]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
! CHECK: %[[VAL_63:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_64:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_65:.*]] = arith.subi %[[VAL_33]], %[[VAL_63]] : index
! CHECK: %[[VAL_66:.*]] = fir.do_loop %[[VAL_67:.*]] = %[[VAL_64]] to %[[VAL_65]] step %[[VAL_63]] unordered iter_args(%[[VAL_68:.*]] = %[[VAL_62]]) -> (!fir.array<1xi32>) {
! CHECK: %[[VAL_69:.*]] = fir.array_fetch %[[VAL_59]], %[[VAL_67]] : (!fir.array<1xi32>, index) -> i32
! CHECK: %[[VAL_70:.*]] = fir.array_update %[[VAL_68]], %[[VAL_69]], %[[VAL_67]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
! CHECK: fir.result %[[VAL_70]] : !fir.array<1xi32>
! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_62]], %[[VAL_71:.*]] to %[[VAL_60]] : !fir.array<1xi32>, !fir.array<1xi32>, !fir.heap<!fir.array<1xi32>>
! CHECK: %[[VAL_72:.*]] = fir.shape %[[VAL_33]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_73:.*]] = fir.embox %[[VAL_60]](%[[VAL_72]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<1xi32>>
! CHECK: %[[VAL_74:.*]] = fir.convert %[[VAL_73]] : (!fir.box<!fir.array<1xi32>>) -> !fir.box<!fir.array<?xi32>>
! CHECK: %[[VAL_75:.*]] = fir.call @_QFac1Pfunc(%[[VAL_74]]) : (!fir.box<!fir.array<?xi32>>) -> i32
! CHECK: %[[VAL_76:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_77:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_78:.*]] = arith.subi %[[VAL_32]], %[[VAL_76]] : index
! CHECK: %[[VAL_79:.*]] = fir.do_loop %[[VAL_80:.*]] = %[[VAL_77]] to %[[VAL_78]] step %[[VAL_76]] unordered iter_args(%[[VAL_81:.*]] = %[[VAL_14]]) -> (!fir.array<?xi32>) {
! CHECK: %[[VAL_82:.*]] = arith.subi %[[VAL_19]], %[[VAL_16]] : index
! CHECK: %[[VAL_83:.*]] = arith.muli %[[VAL_80]], %[[VAL_21]] : index
! CHECK: %[[VAL_84:.*]] = arith.addi %[[VAL_82]], %[[VAL_83]] : index
! CHECK: %[[VAL_85:.*]] = fir.array_update %[[VAL_81]], %[[VAL_75]], %[[VAL_84]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
! CHECK: fir.result %[[VAL_85]] : !fir.array<?xi32>
! CHECK: }
! CHECK: fir.freemem %[[VAL_60]] : !fir.heap<!fir.array<1xi32>>
! CHECK: fir.freemem %[[VAL_56]] : !fir.heap<!fir.array<1xi32>>
! CHECK: fir.result %[[VAL_86:.*]] : !fir.array<?xi32>
! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_11]], %[[VAL_87:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
! CHECK: return
! CHECK: }
! CHECK-LABEL: func @_QFac1Pfunc(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> i32 {
! CHECK: %[[VAL_1:.*]] = fir.alloca i32 {bindc_name = "func", uniq_name = "_QFfuncEfunc"}
! CHECK: %[[VAL_2:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_3:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_4:.*]] = arith.subi %[[VAL_2]], %[[VAL_3]] : i64
! CHECK: %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_4]] : (!fir.box<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: fir.store %[[VAL_6]] to %[[VAL_1]] : !fir.ref<i32>
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
! CHECK: return %[[VAL_7]] : i32
! CHECK: }
subroutine ac2(arr,n)
integer :: arr(:), n
forall (i=1:n:2)
arr(i:i+2) = func((/i/))
end forall
contains
pure function func(a)
integer :: func(3)
integer, intent(in) :: a(:)
func = a(1:3)
end function func
end subroutine ac2
! CHECK-LABEL: func @_QPac2(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arr"},
! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = ".result"}
! CHECK: %[[VAL_3:.*]] = fir.alloca index {bindc_name = ".buff.pos"}
! CHECK: %[[VAL_4:.*]] = fir.alloca index {bindc_name = ".buff.size"}
! CHECK: %[[VAL_5:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
! CHECK: %[[VAL_6:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i32) -> index
! CHECK: %[[VAL_8:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> index
! CHECK: %[[VAL_10:.*]] = arith.constant 2 : i32
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> index
! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.array<?xi32>
! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_11]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<?xi32>) {
! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32
! CHECK: fir.store %[[VAL_16]] to %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i32) -> i64
! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i64) -> index
! CHECK: %[[VAL_21:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (i64) -> index
! CHECK: %[[VAL_23:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_24:.*]] = arith.constant 2 : i32
! CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_23]], %[[VAL_24]] : i32
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i32) -> i64
! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (i64) -> index
! CHECK: %[[VAL_28:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_29:.*]] = arith.subi %[[VAL_27]], %[[VAL_20]] : index
! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_29]], %[[VAL_22]] : index
! CHECK: %[[VAL_31:.*]] = arith.divsi %[[VAL_30]], %[[VAL_22]] : index
! CHECK: %[[VAL_32:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_28]] : index
! CHECK: %[[VAL_33:.*]] = arith.select %[[VAL_32]], %[[VAL_31]], %[[VAL_28]] : index
! CHECK: %[[VAL_34:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_35:.*]] = arith.constant 0 : index
! CHECK: fir.store %[[VAL_35]] to %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_36:.*]] = fir.allocmem !fir.array<1xi32>
! CHECK: %[[VAL_37:.*]] = arith.constant 1 : index
! CHECK: fir.store %[[VAL_37]] to %[[VAL_4]] : !fir.ref<index>
! CHECK: %[[VAL_38:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_40:.*]] = fir.zero_bits !fir.ref<!fir.array<1xi32>>
! CHECK: %[[VAL_41:.*]] = fir.coordinate_of %[[VAL_40]], %[[VAL_39]] : (!fir.ref<!fir.array<1xi32>>, index) -> !fir.ref<i32>
! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (!fir.ref<i32>) -> index
! CHECK: %[[VAL_43:.*]] = fir.load %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_44:.*]] = fir.load %[[VAL_4]] : !fir.ref<index>
! CHECK: %[[VAL_45:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_43]], %[[VAL_45]] : index
! CHECK: %[[VAL_47:.*]] = arith.cmpi sle, %[[VAL_44]], %[[VAL_46]] : index
! CHECK: %[[VAL_48:.*]] = fir.if %[[VAL_47]] -> (!fir.heap<!fir.array<1xi32>>) {
! CHECK: %[[VAL_49:.*]] = arith.constant 2 : index
! CHECK: %[[VAL_50:.*]] = arith.muli %[[VAL_46]], %[[VAL_49]] : index
! CHECK: fir.store %[[VAL_50]] to %[[VAL_4]] : !fir.ref<index>
! CHECK: %[[VAL_51:.*]] = arith.muli %[[VAL_50]], %[[VAL_42]] : index
! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_36]] : (!fir.heap<!fir.array<1xi32>>) -> !fir.ref<i8>
! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (index) -> i64
! CHECK: %[[VAL_54:.*]] = fir.call @realloc(%[[VAL_52]], %[[VAL_53]]) : (!fir.ref<i8>, i64) -> !fir.ref<i8>
! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (!fir.ref<i8>) -> !fir.heap<!fir.array<1xi32>>
! CHECK: fir.result %[[VAL_55]] : !fir.heap<!fir.array<1xi32>>
! CHECK: } else {
! CHECK: fir.result %[[VAL_36]] : !fir.heap<!fir.array<1xi32>>
! CHECK: }
! CHECK: %[[VAL_56:.*]] = fir.coordinate_of %[[VAL_57:.*]], %[[VAL_43]] : (!fir.heap<!fir.array<1xi32>>, index) -> !fir.ref<i32>
! CHECK: fir.store %[[VAL_38]] to %[[VAL_56]] : !fir.ref<i32>
! CHECK: fir.store %[[VAL_46]] to %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_3]] : !fir.ref<index>
! CHECK: %[[VAL_59:.*]] = fir.shape %[[VAL_58]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_60:.*]] = fir.array_load %[[VAL_57]](%[[VAL_59]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
! CHECK: %[[VAL_61:.*]] = fir.allocmem !fir.array<1xi32>
! CHECK: %[[VAL_62:.*]] = fir.shape %[[VAL_34]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_63:.*]] = fir.array_load %[[VAL_61]](%[[VAL_62]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
! CHECK: %[[VAL_64:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_65:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_66:.*]] = arith.subi %[[VAL_34]], %[[VAL_64]] : index
! CHECK: %[[VAL_67:.*]] = fir.do_loop %[[VAL_68:.*]] = %[[VAL_65]] to %[[VAL_66]] step %[[VAL_64]] unordered iter_args(%[[VAL_69:.*]] = %[[VAL_63]]) -> (!fir.array<1xi32>) {
! CHECK: %[[VAL_70:.*]] = fir.array_fetch %[[VAL_60]], %[[VAL_68]] : (!fir.array<1xi32>, index) -> i32
! CHECK: %[[VAL_71:.*]] = fir.array_update %[[VAL_69]], %[[VAL_70]], %[[VAL_68]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
! CHECK: fir.result %[[VAL_71]] : !fir.array<1xi32>
! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_63]], %[[VAL_72:.*]] to %[[VAL_61]] : !fir.array<1xi32>, !fir.array<1xi32>, !fir.heap<!fir.array<1xi32>>
! CHECK: %[[VAL_73:.*]] = fir.shape %[[VAL_34]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_74:.*]] = fir.embox %[[VAL_61]](%[[VAL_73]]) : (!fir.heap<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<1xi32>>
! CHECK: %[[VAL_75:.*]] = arith.constant 3 : i64
! CHECK: %[[VAL_76:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_77:.*]] = arith.subi %[[VAL_75]], %[[VAL_76]] : i64
! CHECK: %[[VAL_78:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_79:.*]] = arith.addi %[[VAL_77]], %[[VAL_78]] : i64
! CHECK: %[[VAL_80:.*]] = fir.convert %[[VAL_79]] : (i64) -> index
! CHECK: %[[VAL_81:.*]] = fir.call @llvm.stacksave() : () -> !fir.ref<i8>
! CHECK: %[[VAL_82:.*]] = fir.shape %[[VAL_80]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_83:.*]] = fir.convert %[[VAL_74]] : (!fir.box<!fir.array<1xi32>>) -> !fir.box<!fir.array<?xi32>>
! CHECK: %[[VAL_84:.*]] = fir.call @_QFac2Pfunc(%[[VAL_83]]) : (!fir.box<!fir.array<?xi32>>) -> !fir.array<3xi32>
! CHECK: fir.save_result %[[VAL_84]] to %[[VAL_2]](%[[VAL_82]]) : !fir.array<3xi32>, !fir.ref<!fir.array<3xi32>>, !fir.shape<1>
! CHECK: %[[VAL_85:.*]] = fir.shape %[[VAL_80]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_86:.*]] = fir.array_load %[[VAL_2]](%[[VAL_85]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.array<3xi32>
! CHECK: %[[VAL_87:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_88:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_89:.*]] = arith.subi %[[VAL_33]], %[[VAL_87]] : index
! CHECK: %[[VAL_90:.*]] = fir.do_loop %[[VAL_91:.*]] = %[[VAL_88]] to %[[VAL_89]] step %[[VAL_87]] unordered iter_args(%[[VAL_92:.*]] = %[[VAL_15]]) -> (!fir.array<?xi32>) {
! CHECK: %[[VAL_93:.*]] = fir.array_fetch %[[VAL_86]], %[[VAL_91]] : (!fir.array<3xi32>, index) -> i32
! CHECK: %[[VAL_94:.*]] = arith.subi %[[VAL_20]], %[[VAL_17]] : index
! CHECK: %[[VAL_95:.*]] = arith.muli %[[VAL_91]], %[[VAL_22]] : index
! CHECK: %[[VAL_96:.*]] = arith.addi %[[VAL_94]], %[[VAL_95]] : index
! CHECK: %[[VAL_97:.*]] = fir.array_update %[[VAL_92]], %[[VAL_93]], %[[VAL_96]] : (!fir.array<?xi32>, i32, index) -> !fir.array<?xi32>
! CHECK: fir.result %[[VAL_97]] : !fir.array<?xi32>
! CHECK: }
! CHECK: fir.call @llvm.stackrestore(%[[VAL_81]]) : (!fir.ref<i8>) -> ()
! CHECK: fir.freemem %[[VAL_61]] : !fir.heap<!fir.array<1xi32>>
! CHECK: fir.freemem %[[VAL_57]] : !fir.heap<!fir.array<1xi32>>
! CHECK: fir.result %[[VAL_98:.*]] : !fir.array<?xi32>
! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_12]], %[[VAL_99:.*]] to %[[VAL_0]] : !fir.array<?xi32>, !fir.array<?xi32>, !fir.box<!fir.array<?xi32>>
! CHECK: return
! CHECK: }
! CHECK-LABEL: func @_QFac2Pfunc(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}) -> !fir.array<3xi32> {
! CHECK: %[[VAL_1:.*]] = arith.constant 3 : index
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "func", uniq_name = "_QFfuncEfunc"}
! CHECK: %[[VAL_3:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_4:.*]] = fir.array_load %[[VAL_2]](%[[VAL_3]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.array<3xi32>
! CHECK: %[[VAL_5:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
! CHECK: %[[VAL_7:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i64) -> index
! CHECK: %[[VAL_9:.*]] = arith.constant 3 : i64
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
! CHECK: %[[VAL_11:.*]] = fir.slice %[[VAL_6]], %[[VAL_10]], %[[VAL_8]] : (index, index, index) -> !fir.slice<1>
! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]] {{\[}}%[[VAL_11]]] : (!fir.box<!fir.array<?xi32>>, !fir.slice<1>) -> !fir.array<?xi32>
! CHECK: %[[VAL_13:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_14:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_15:.*]] = arith.subi %[[VAL_1]], %[[VAL_13]] : index
! CHECK: %[[VAL_16:.*]] = fir.do_loop %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_13]] unordered iter_args(%[[VAL_18:.*]] = %[[VAL_4]]) -> (!fir.array<3xi32>) {
! CHECK: %[[VAL_19:.*]] = fir.array_fetch %[[VAL_12]], %[[VAL_17]] : (!fir.array<?xi32>, index) -> i32
! CHECK: %[[VAL_20:.*]] = fir.array_update %[[VAL_18]], %[[VAL_19]], %[[VAL_17]] : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32>
! CHECK: fir.result %[[VAL_20]] : !fir.array<3xi32>
! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_4]], %[[VAL_21:.*]] to %[[VAL_2]] : !fir.array<3xi32>, !fir.array<3xi32>, !fir.ref<!fir.array<3xi32>>
! CHECK: %[[VAL_22:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.array<3xi32>>
! CHECK: return %[[VAL_22]] : !fir.array<3xi32>
! CHECK: }

flang/test/Lower/forall/forall-2.f90

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 Lines
! CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_24]], %[[VAL_19]] : index ! CHECK: %[[VAL_25:.*]] = arith.addi %[[VAL_24]], %[[VAL_19]] : index
! CHECK: %[[VAL_26:.*]] = arith.divsi %[[VAL_25]], %[[VAL_19]] : index ! CHECK: %[[VAL_26:.*]] = arith.divsi %[[VAL_25]], %[[VAL_19]] : index
! CHECK: %[[VAL_27:.*]] = arith.cmpi sgt, %[[VAL_26]], %[[VAL_23]] : index ! CHECK: %[[VAL_27:.*]] = arith.cmpi sgt, %[[VAL_26]], %[[VAL_23]] : index
! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_23]] : index ! CHECK: %[[VAL_28:.*]] = arith.select %[[VAL_27]], %[[VAL_26]], %[[VAL_23]] : index
! CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32> ! CHECK: %[[VAL_29:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> i64 ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> i64
! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (i64) -> index ! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (i64) -> index
! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_31]], %[[VAL_15]] : index ! CHECK: %[[VAL_32:.*]] = arith.subi %[[VAL_31]], %[[VAL_15]] : index
! CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
! CHECK: %[[VAL_40:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_40]], %[[VAL_39]] : i32
! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_28]], %[[VAL_33]] : index ! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_28]], %[[VAL_33]] : index
! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_13]]) -> (!fir.array<10x10xi32>) { ! CHECK: %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_34]] to %[[VAL_35]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_13]]) -> (!fir.array<10x10xi32>) {
! CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
! CHECK: %[[VAL_40:.*]] = arith.constant 0 : i32
! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_40]], %[[VAL_39]] : i32
! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_17]], %[[VAL_15]] : index ! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_17]], %[[VAL_15]] : index
! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_37]], %[[VAL_19]] : index ! CHECK: %[[VAL_43:.*]] = arith.muli %[[VAL_37]], %[[VAL_19]] : index
! CHECK: %[[VAL_44:.*]] = arith.addi %[[VAL_42]], %[[VAL_43]] : index ! CHECK: %[[VAL_44:.*]] = arith.addi %[[VAL_42]], %[[VAL_43]] : index
! CHECK: %[[VAL_45:.*]] = fir.array_update %[[VAL_38]], %[[VAL_41]], %[[VAL_44]], %[[VAL_32]] : (!fir.array<10x10xi32>, i32, index, index) -> !fir.array<10x10xi32> ! CHECK: %[[VAL_45:.*]] = fir.array_update %[[VAL_38]], %[[VAL_41]], %[[VAL_44]], %[[VAL_32]] : (!fir.array<10x10xi32>, i32, index, index) -> !fir.array<10x10xi32>
! CHECK: fir.result %[[VAL_45]] : !fir.array<10x10xi32> ! CHECK: fir.result %[[VAL_45]] : !fir.array<10x10xi32>
! CHECK: } ! CHECK: }
! CHECK: fir.result %[[VAL_46:.*]] : !fir.array<10x10xi32> ! CHECK: fir.result %[[VAL_46:.*]] : !fir.array<10x10xi32>
! CHECK: } ! CHECK: }
Show All 20 Lines
! CHECK: %[[VAL_8:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_8:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> index ! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> index
! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_10:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32> ! CHECK: %[[VAL_12:.*]] = fir.array_load %[[VAL_0]](%[[VAL_11]]) : (!fir.ref<!fir.array<1xi32>>, !fir.shape<1>) -> !fir.array<1xi32>
! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<1xi32>) { ! CHECK: %[[VAL_13:.*]] = fir.do_loop %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_9]] step %[[VAL_10]] unordered iter_args(%[[VAL_15:.*]] = %[[VAL_12]]) -> (!fir.array<1xi32>) {
! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32 ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_14]] : (index) -> i32
! CHECK: fir.store %[[VAL_16]] to %[[VAL_2]] : !fir.ref<i32> ! CHECK: fir.store %[[VAL_16]] to %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i32 ! CHECK-DAG: %[[VAL_18:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_18:.*]] = arith.constant 1 : index ! CHECK-DAG: %[[VAL_19:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_19:.*]] = arith.constant 1 : i64
! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i64) -> index ! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i64) -> index
! CHECK: %[[VAL_21:.*]] = arith.addi %[[VAL_18]], %[[VAL_4]] : index ! CHECK: %[[VAL_21:.*]] = arith.addi %[[VAL_18]], %[[VAL_4]] : index
! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_21]], %[[VAL_18]] : index ! CHECK: %[[VAL_22:.*]] = arith.subi %[[VAL_21]], %[[VAL_18]] : index
! CHECK: %[[VAL_23:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_23:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (i32) -> i64 ! CHECK: %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (i32) -> i64
! CHECK: %[[VAL_25:.*]] = fir.undefined index ! CHECK: %[[VAL_25:.*]] = fir.undefined index
! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2> ! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_4]], %[[VAL_5]] : (index, index) -> !fir.shape<2>
! CHECK: %[[VAL_27:.*]] = fir.slice %[[VAL_18]], %[[VAL_22]], %[[VAL_20]], %[[VAL_24]], %[[VAL_25]], %[[VAL_25]] : (index, index, index, i64, index, index) -> !fir.slice<2> ! CHECK: %[[VAL_27:.*]] = fir.slice %[[VAL_18]], %[[VAL_22]], %[[VAL_20]], %[[VAL_24]], %[[VAL_25]], %[[VAL_25]] : (index, index, index, i64, index, index) -> !fir.slice<2>
! CHECK: %[[VAL_28:.*]] = fir.embox %[[VAL_1]](%[[VAL_26]]) {{\[}}%[[VAL_27]]] : (!fir.ref<!fir.array<2x2xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xi32>> ! CHECK: %[[VAL_28:.*]] = fir.embox %[[VAL_1]](%[[VAL_26]]) {{\[}}%[[VAL_27]]] : (!fir.ref<!fir.array<2x2xi32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?xi32>>
! CHECK: %[[VAL_29:.*]] = fir.call @_QPe(%[[VAL_28]]) : (!fir.box<!fir.array<?xi32>>) -> i32 ! CHECK: %[[VAL_29:.*]] = fir.call @_QPe(%[[VAL_28]]) : (!fir.box<!fir.array<?xi32>>) -> i32
! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_29]], %[[VAL_17]] : i32 ! CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_29]], %[[VAL_17]] : i32
! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_31:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_32:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_32:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_32]] : (i32) -> i64 ! CHECK: %[[VAL_33:.*]] = fir.convert %[[VAL_32]] : (i32) -> i64
! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i64) -> index ! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i64) -> index
! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_34]], %[[VAL_31]] : index ! CHECK: %[[VAL_35:.*]] = arith.subi %[[VAL_34]], %[[VAL_31]] : index
! CHECK: %[[VAL_36:.*]] = fir.array_update %[[VAL_15]], %[[VAL_30]], %[[VAL_35]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32> ! CHECK: %[[VAL_36:.*]] = fir.array_update %[[VAL_15]], %[[VAL_30]], %[[VAL_35]] : (!fir.array<1xi32>, i32, index) -> !fir.array<1xi32>
! CHECK: fir.result %[[VAL_36]] : !fir.array<1xi32> ! CHECK: fir.result %[[VAL_36]] : !fir.array<1xi32>
Show All 17 Lines

flang/test/Lower/forall/forall-construct-2.f90

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
! CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK: %[[VAL_35:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i32) -> i64 ! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i32) -> i64
! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i64) -> index ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i64) -> index
! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_34]] : index ! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_34]] : index
! CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32> ! CHECK: %[[VAL_39:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i32) -> i64 ! CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (i32) -> i64
! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i64) -> index ! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i64) -> index
! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_41]], %[[VAL_34]] : index ! CHECK: %[[VAL_42:.*]] = arith.subi %[[VAL_41]], %[[VAL_34]] : index
! CHECK: %[[VAL_54:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_38]], %[[VAL_42]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_43:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_43:.*]] = arith.constant 1 : index
! CHECK-DAG: %[[VAL_44:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK-DAG: %[[VAL_44:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK-DAG: %[[VAL_45:.*]] = arith.constant 1 : i32 ! CHECK-DAG: %[[VAL_45:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_44]], %[[VAL_45]] : i32 ! CHECK: %[[VAL_46:.*]] = arith.addi %[[VAL_44]], %[[VAL_45]] : i32
! CHECK: %[[VAL_47:.*]] = fir.convert %[[VAL_46]] : (i32) -> i64 ! CHECK: %[[VAL_47:.*]] = fir.convert %[[VAL_46]] : (i32) -> i64
! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (i64) -> index ! CHECK: %[[VAL_48:.*]] = fir.convert %[[VAL_47]] : (i64) -> index
! CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_48]], %[[VAL_43]] : index ! CHECK: %[[VAL_49:.*]] = arith.subi %[[VAL_48]], %[[VAL_43]] : index
! CHECK: %[[VAL_50:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32> ! CHECK: %[[VAL_50:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_50]] : (i32) -> i64 ! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_50]] : (i32) -> i64
! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i64) -> index ! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_51]] : (i64) -> index
! CHECK: %[[VAL_53:.*]] = arith.subi %[[VAL_52]], %[[VAL_43]] : index ! CHECK: %[[VAL_53:.*]] = arith.subi %[[VAL_52]], %[[VAL_43]] : index
! CHECK: %[[VAL_54:.*]] = fir.array_fetch %[[VAL_23]], %[[VAL_38]], %[[VAL_42]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_55:.*]] = fir.array_fetch %[[VAL_25]], %[[VAL_49]], %[[VAL_53]] : (!fir.array<200x200xf32>, index, index) -> f32 ! CHECK: %[[VAL_55:.*]] = fir.array_fetch %[[VAL_25]], %[[VAL_49]], %[[VAL_53]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_56:.*]] = arith.addf %[[VAL_54]], %[[VAL_55]] : f32 ! CHECK: %[[VAL_56:.*]] = arith.addf %[[VAL_54]], %[[VAL_55]] : f32
! CHECK: %[[VAL_57:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_57:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64 ! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index ! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index
! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_57]] : index ! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_57]] : index
! CHECK: %[[VAL_62:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32> ! CHECK: %[[VAL_62:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

flang/test/Lower/forall/forall-construct-3.f90

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
! CHECK: %[[VAL_48:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32> ! CHECK: %[[VAL_48:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (i32) -> i64 ! CHECK: %[[VAL_49:.*]] = fir.convert %[[VAL_48]] : (i32) -> i64
! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i64) -> index ! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i64) -> index
! CHECK: %[[VAL_51:.*]] = arith.subi %[[VAL_50]], %[[VAL_47]] : index ! CHECK: %[[VAL_51:.*]] = arith.subi %[[VAL_50]], %[[VAL_47]] : index
! CHECK: %[[VAL_52:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK: %[[VAL_52:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_52]] : (i32) -> i64 ! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_52]] : (i32) -> i64
! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i64) -> index ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_53]] : (i64) -> index
! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_54]], %[[VAL_47]] : index ! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_54]], %[[VAL_47]] : index
! CHECK: %[[VAL_67:.*]] = fir.array_fetch %[[VAL_24]], %[[VAL_51]], %[[VAL_55]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_56:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_56:.*]] = arith.constant 1 : index
! CHECK-DAG: %[[VAL_57:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32> ! CHECK-DAG: %[[VAL_57:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
! CHECK-DAG: %[[VAL_58:.*]] = arith.constant 1 : i32 ! CHECK-DAG: %[[VAL_58:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_59:.*]] = arith.addi %[[VAL_57]], %[[VAL_58]] : i32 ! CHECK: %[[VAL_59:.*]] = arith.addi %[[VAL_57]], %[[VAL_58]] : i32
! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i32) -> i64 ! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i32) -> i64
! CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i64) -> index ! CHECK: %[[VAL_61:.*]] = fir.convert %[[VAL_60]] : (i64) -> index
! CHECK: %[[VAL_62:.*]] = arith.subi %[[VAL_61]], %[[VAL_56]] : index ! CHECK: %[[VAL_62:.*]] = arith.subi %[[VAL_61]], %[[VAL_56]] : index
! CHECK: %[[VAL_63:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK: %[[VAL_63:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
! CHECK: %[[VAL_64:.*]] = fir.convert %[[VAL_63]] : (i32) -> i64 ! CHECK: %[[VAL_64:.*]] = fir.convert %[[VAL_63]] : (i32) -> i64
! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_64]] : (i64) -> index ! CHECK: %[[VAL_65:.*]] = fir.convert %[[VAL_64]] : (i64) -> index
! CHECK: %[[VAL_66:.*]] = arith.subi %[[VAL_65]], %[[VAL_56]] : index ! CHECK: %[[VAL_66:.*]] = arith.subi %[[VAL_65]], %[[VAL_56]] : index
! CHECK: %[[VAL_67:.*]] = fir.array_fetch %[[VAL_24]], %[[VAL_51]], %[[VAL_55]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_68:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_62]], %[[VAL_66]] : (!fir.array<200x200xf32>, index, index) -> f32 ! CHECK: %[[VAL_68:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_62]], %[[VAL_66]] : (!fir.array<200x200xf32>, index, index) -> f32
! CHECK: %[[VAL_69:.*]] = arith.addf %[[VAL_67]], %[[VAL_68]] : f32 ! CHECK: %[[VAL_69:.*]] = arith.addf %[[VAL_67]], %[[VAL_68]] : f32
! CHECK: %[[VAL_70:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_70:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_71:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32> ! CHECK: %[[VAL_71:.*]] = fir.load %[[VAL_6]] : !fir.ref<i32>
! CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_71]] : (i32) -> i64 ! CHECK: %[[VAL_72:.*]] = fir.convert %[[VAL_71]] : (i32) -> i64
! CHECK: %[[VAL_73:.*]] = fir.convert %[[VAL_72]] : (i64) -> index ! CHECK: %[[VAL_73:.*]] = fir.convert %[[VAL_72]] : (i64) -> index
! CHECK: %[[VAL_74:.*]] = arith.subi %[[VAL_73]], %[[VAL_70]] : index ! CHECK: %[[VAL_74:.*]] = arith.subi %[[VAL_73]], %[[VAL_70]] : index
! CHECK: %[[VAL_75:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32> ! CHECK: %[[VAL_75:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

flang/test/Lower/forall/forall-construct.f90

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
! CHECK: %[[VAL_54:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_54:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (i32) -> i64 ! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (i32) -> i64
! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i64) -> index ! CHECK: %[[VAL_56:.*]] = fir.convert %[[VAL_55]] : (i64) -> index
! CHECK: %[[VAL_57:.*]] = arith.subi %[[VAL_56]], %[[VAL_53]] : index ! CHECK: %[[VAL_57:.*]] = arith.subi %[[VAL_56]], %[[VAL_53]] : index
! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> ! CHECK: %[[VAL_58:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64 ! CHECK: %[[VAL_59:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index ! CHECK: %[[VAL_60:.*]] = fir.convert %[[VAL_59]] : (i64) -> index
! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_53]] : index ! CHECK: %[[VAL_61:.*]] = arith.subi %[[VAL_60]], %[[VAL_53]] : index
! CHECK: %[[VAL_62:.*]] = arith.constant 3.140000e+00 : f32 ! CHECK-DAG: %[[VAL_62:.*]] = arith.constant 3.140000e+00 : f32
! CHECK: %[[VAL_63:.*]] = fir.array_fetch %[[VAL_31]], %[[VAL_57]], %[[VAL_61]] : (!fir.array<?x?xf32>, index, index) -> f32 ! CHECK-DAG: %[[VAL_63:.*]] = fir.array_fetch %[[VAL_31]], %[[VAL_57]], %[[VAL_61]] : (!fir.array<?x?xf32>, index, index) -> f32
! CHECK: %[[VAL_64:.*]] = arith.divf %[[VAL_63]], %[[VAL_62]] : f32 ! CHECK: %[[VAL_64:.*]] = arith.divf %[[VAL_63]], %[[VAL_62]] : f32
! CHECK: %[[VAL_65:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_65:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_66:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> ! CHECK: %[[VAL_66:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_66]] : (i32) -> i64 ! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_66]] : (i32) -> i64
! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_67]] : (i64) -> index ! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_67]] : (i64) -> index
! CHECK: %[[VAL_69:.*]] = arith.subi %[[VAL_68]], %[[VAL_65]] : index ! CHECK: %[[VAL_69:.*]] = arith.subi %[[VAL_68]], %[[VAL_65]] : index
! CHECK: %[[VAL_70:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_70:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_70]] : (i32) -> i64 ! CHECK: %[[VAL_71:.*]] = fir.convert %[[VAL_70]] : (i32) -> i64
Show All 14 Lines

flang/test/Lower/forall/forall-ranked.f90

Show All 34 Lines
! CHECK: %[[VAL_31:.*]] = arith.select %[[VAL_30]], %[[VAL_29]], %[[VAL_26]] : index ! CHECK: %[[VAL_31:.*]] = arith.select %[[VAL_30]], %[[VAL_29]], %[[VAL_26]] : index
! CHECK: %[[VAL_32:.*]] = fir.field_index arr, !fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}> ! CHECK: %[[VAL_32:.*]] = fir.field_index arr, !fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>
! CHECK-DAG: %[[VAL_33:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32> ! CHECK-DAG: %[[VAL_33:.*]] = fir.load %[[VAL_0]] : !fir.ref<i32>
! CHECK-DAG: %[[VAL_34:.*]] = arith.constant 4 : i32 ! CHECK-DAG: %[[VAL_34:.*]] = arith.constant 4 : i32
! CHECK: %[[VAL_35:.*]] = arith.addi %[[VAL_33]], %[[VAL_34]] : i32 ! CHECK: %[[VAL_35:.*]] = arith.addi %[[VAL_33]], %[[VAL_34]] : i32
! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i32) -> i64 ! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i32) -> i64
! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i64) -> index ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_36]] : (i64) -> index
! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_16]] : index ! CHECK: %[[VAL_38:.*]] = arith.subi %[[VAL_37]], %[[VAL_16]] : index
! CHECK: %[[VAL_45:.*]] = fir.call @_QPf(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_40:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_40:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_31]], %[[VAL_39]] : index ! CHECK: %[[VAL_41:.*]] = arith.subi %[[VAL_31]], %[[VAL_39]] : index
! CHECK: %[[VAL_42:.*]] = fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_39]] unordered iter_args(%[[VAL_44:.*]] = %[[VAL_13]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) { ! CHECK: %[[VAL_42:.*]] = fir.do_loop %[[VAL_43:.*]] = %[[VAL_40]] to %[[VAL_41]] step %[[VAL_39]] unordered iter_args(%[[VAL_44:.*]] = %[[VAL_13]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>) {
! CHECK: %[[VAL_45:.*]] = fir.call @_QPf(%[[VAL_0]]) : (!fir.ref<i32>) -> i32
! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_17]], %[[VAL_17]] : index ! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_17]], %[[VAL_17]] : index
! CHECK: %[[VAL_47:.*]] = arith.muli %[[VAL_43]], %[[VAL_23]] : index ! CHECK: %[[VAL_47:.*]] = arith.muli %[[VAL_43]], %[[VAL_23]] : index
! CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_46]], %[[VAL_47]] : index ! CHECK: %[[VAL_48:.*]] = arith.addi %[[VAL_46]], %[[VAL_47]] : index
! CHECK: %[[VAL_49:.*]] = fir.array_update %[[VAL_44]], %[[VAL_45]], %[[VAL_21]], %[[VAL_48]], %[[VAL_32]], %[[VAL_38]] : (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>, i32, index, index, !fir.field, index) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>> ! CHECK: %[[VAL_49:.*]] = fir.array_update %[[VAL_44]], %[[VAL_45]], %[[VAL_21]], %[[VAL_48]], %[[VAL_32]], %[[VAL_38]] : (!fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>, i32, index, index, !fir.field, index) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>
! CHECK: fir.result %[[VAL_49]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>> ! CHECK: fir.result %[[VAL_49]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>
! CHECK: } ! CHECK: }
! CHECK: fir.result %[[VAL_50:.*]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>> ! CHECK: fir.result %[[VAL_50:.*]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_ranked_dimensionTt{arr:!fir.array<11xi32>}>>
! CHECK: } ! CHECK: }
Show All 20 Lines

flang/test/Lower/forall/forall-slice.f90

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i32) -> i64 ! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i32) -> i64
! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_45]] : (i64) -> index ! CHECK: %[[VAL_46:.*]] = fir.convert %[[VAL_45]] : (i64) -> index
! CHECK: %[[VAL_47:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_47:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_46]], %[[VAL_40]] : index ! CHECK: %[[VAL_48:.*]] = arith.subi %[[VAL_46]], %[[VAL_40]] : index
! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_48]], %[[VAL_43]] : index ! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_48]], %[[VAL_43]] : index
! CHECK: %[[VAL_50:.*]] = arith.divsi %[[VAL_49]], %[[VAL_43]] : index ! CHECK: %[[VAL_50:.*]] = arith.divsi %[[VAL_49]], %[[VAL_43]] : index
! CHECK: %[[VAL_51:.*]] = arith.cmpi sgt, %[[VAL_50]], %[[VAL_47]] : index ! CHECK: %[[VAL_51:.*]] = arith.cmpi sgt, %[[VAL_50]], %[[VAL_47]] : index
! CHECK: %[[VAL_52:.*]] = arith.select %[[VAL_51]], %[[VAL_50]], %[[VAL_47]] : index ! CHECK: %[[VAL_52:.*]] = arith.select %[[VAL_51]], %[[VAL_50]], %[[VAL_47]] : index
! CHECK: %[[VAL_59:.*]] = fir.call @_QPf(%[[VAL_3]]) : (!fir.ref<i32>) -> i32
! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_53:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_54:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_54:.*]] = arith.constant 0 : index
! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_52]], %[[VAL_53]] : index ! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_52]], %[[VAL_53]] : index
! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_25]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) { ! CHECK: %[[VAL_56:.*]] = fir.do_loop %[[VAL_57:.*]] = %[[VAL_54]] to %[[VAL_55]] step %[[VAL_53]] unordered iter_args(%[[VAL_58:.*]] = %[[VAL_25]]) -> (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>) {
! CHECK: %[[VAL_59:.*]] = fir.call @_QPf(%[[VAL_3]]) : (!fir.ref<i32>) -> i32
! CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_40]], %[[VAL_37]] : index ! CHECK: %[[VAL_60:.*]] = arith.subi %[[VAL_40]], %[[VAL_37]] : index
! CHECK: %[[VAL_61:.*]] = arith.muli %[[VAL_57]], %[[VAL_43]] : index ! CHECK: %[[VAL_61:.*]] = arith.muli %[[VAL_57]], %[[VAL_43]] : index
! CHECK: %[[VAL_62:.*]] = arith.addi %[[VAL_60]], %[[VAL_61]] : index ! CHECK: %[[VAL_62:.*]] = arith.addi %[[VAL_60]], %[[VAL_61]] : index
! CHECK: %[[VAL_63:.*]] = fir.array_update %[[VAL_58]], %[[VAL_59]], %[[VAL_31]], %[[VAL_35]], %[[VAL_36]], %[[VAL_62]] : (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>, i32, index, index, !fir.field, index) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>> ! CHECK: %[[VAL_63:.*]] = fir.array_update %[[VAL_58]], %[[VAL_59]], %[[VAL_31]], %[[VAL_35]], %[[VAL_36]], %[[VAL_62]] : (!fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>, i32, index, index, !fir.field, index) -> !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>
! CHECK: fir.result %[[VAL_63]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>> ! CHECK: fir.result %[[VAL_63]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>
! CHECK: } ! CHECK: }
! CHECK: fir.result %[[VAL_64:.*]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>> ! CHECK: fir.result %[[VAL_64:.*]] : !fir.array<10x10x!fir.type<_QFtest_forall_with_sliceTt{arr:!fir.array<11xi32>}>>
! CHECK: } ! CHECK: }
Show All 23 Lines

flang/test/Lower/forall/test9.f90

Show All 10 Linessubroutine test9(a,b,n)
real, intent(inout) :: a(n) real, intent(inout) :: a(n)
real, intent(in) :: b(n) real, intent(in) :: b(n)
loopy: FORALL (i=1:n-1) loopy: FORALL (i=1:n-1)
a(i+1) = a(i) + b(i) a(i+1) = a(i) + b(i)
END FORALL loopy END FORALL loopy
end subroutine test9 end subroutine test9
! CHECK-LABEL: func @_QPtest9( ! CHECK-LABEL: func @_QPtest9(
! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.array<?xf32>>{{.*}}, %[[VAL_2:.*]]: !fir.ref<i32>{{.*}}) { ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.array<?xf32>> {fir.bindc_name = "a"},
! CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<!fir.array<?xf32>> {fir.bindc_name = "b"},
! CHECK-SAME: %[[VAL_2:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"} ! CHECK: %[[VAL_3:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_4:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> i64 ! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (i32) -> i64
! CHECK: %[[VAL_6A:.*]] = fir.convert %[[VAL_5]] : (i64) -> index ! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> index
! CHECK: %[[C0:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_7:.*]] = arith.constant 0 : index
! CHECK: %[[CMP:.*]] = arith.cmpi sgt, %[[VAL_6A]], %[[C0]] : index ! CHECK: %[[VAL_8:.*]] = arith.cmpi sgt, %[[VAL_6]], %[[VAL_7]] : index
! CHECK: %[[VAL_6:.*]] = arith.select %[[CMP]], %[[VAL_6A]], %[[C0]] : index ! CHECK: %[[VAL_9:.*]] = arith.select %[[VAL_8]], %[[VAL_6]], %[[VAL_7]] : index
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_10:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_7]] : (i32) -> i64 ! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> i64
! CHECK: %[[VAL_9A:.*]] = fir.convert %[[VAL_8]] : (i64) -> index ! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
! CHECK: %[[C0_2:.*]] = arith.constant 0 : index ! CHECK: %[[VAL_13:.*]] = arith.constant 0 : index
! CHECK: %[[CMP_2:.*]] = arith.cmpi sgt, %[[VAL_9A]], %[[C0_2]] : index ! CHECK: %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[VAL_13]] : index
! CHECK: %[[VAL_9:.*]] = arith.select %[[CMP_2]], %[[VAL_9A]], %[[C0_2]] : index ! CHECK: %[[VAL_15:.*]] = arith.select %[[VAL_14]], %[[VAL_12]], %[[VAL_13]] : index
! CHECK: %[[VAL_10:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_11:.*]] = fir.convert %[[VAL_10]] : (i32) -> index ! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i32) -> index
! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32> ! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_2]] : !fir.ref<i32>
! CHECK: %[[VAL_13:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_19:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_13]] : i32 ! CHECK: %[[VAL_20:.*]] = arith.subi %[[VAL_18]], %[[VAL_19]] : i32
! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> index ! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index
! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_22:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_17:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_23:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_18:.*]] = fir.array_load %[[VAL_0]](%[[VAL_17]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> ! CHECK: %[[VAL_24:.*]] = fir.array_load %[[VAL_0]](%[[VAL_23]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
! CHECK: %[[VAL_19:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_25:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_20:.*]] = fir.array_load %[[VAL_0]](%[[VAL_19]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> ! CHECK: %[[VAL_26:.*]] = fir.array_load %[[VAL_0]](%[[VAL_25]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
! CHECK: %[[VAL_21:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1> ! CHECK: %[[VAL_27:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1>
! CHECK: %[[VAL_22:.*]] = fir.array_load %[[VAL_1]](%[[VAL_21]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32> ! CHECK: %[[VAL_28:.*]] = fir.array_load %[[VAL_1]](%[[VAL_27]]) : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.array<?xf32>
! CHECK: %[[VAL_23:.*]] = fir.do_loop %[[VAL_24:.*]] = %[[VAL_11]] to %[[VAL_15]] step %[[VAL_16]] unordered iter_args(%[[VAL_25:.*]] = %[[VAL_18]]) -> (!fir.array<?xf32>) { ! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_17]] to %[[VAL_21]] step %[[VAL_22]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_24]]) -> (!fir.array<?xf32>) {
! CHECK: %[[VAL_26:.*]] = fir.convert %[[VAL_24]] : (index) -> i32 ! CHECK: %[[VAL_32:.*]] = fir.convert %[[VAL_30]] : (index) -> i32
! CHECK: fir.store %[[VAL_26]] to %[[VAL_3]] : !fir.ref<i32> ! CHECK: fir.store %[[VAL_32]] to %[[VAL_3]] : !fir.ref<i32>
! CHECK: %[[VAL_27:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_33:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_28:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> ! CHECK: %[[VAL_34:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (i32) -> i64 ! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]] : (i32) -> i64
! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i64) -> index ! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_35]] : (i64) -> index
! CHECK: %[[VAL_31:.*]] = arith.subi %[[VAL_30]], %[[VAL_27]] : index ! CHECK: %[[VAL_37:.*]] = arith.subi %[[VAL_36]], %[[VAL_33]] : index
! CHECK: %[[VAL_32:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_38:.*]] = fir.array_fetch %[[VAL_26]], %[[VAL_37]] : (!fir.array<?xf32>, index) -> f32
! CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> ! CHECK: %[[VAL_39:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_34:.*]] = fir.convert %[[VAL_33]] : (i32) -> i64 ! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_34]] : (i64) -> index ! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (i32) -> i64
! CHECK: %[[VAL_36:.*]] = arith.subi %[[VAL_35]], %[[VAL_32]] : index ! CHECK: %[[VAL_42:.*]] = fir.convert %[[VAL_41]] : (i64) -> index
! CHECK: %[[VAL_37:.*]] = fir.array_fetch %[[VAL_20]], %[[VAL_31]] : (!fir.array<?xf32>, index) -> f32 ! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_42]], %[[VAL_39]] : index
! CHECK: %[[VAL_38:.*]] = fir.array_fetch %[[VAL_22]], %[[VAL_36]] : (!fir.array<?xf32>, index) -> f32 ! CHECK: %[[VAL_44:.*]] = fir.array_fetch %[[VAL_28]], %[[VAL_43]] : (!fir.array<?xf32>, index) -> f32
! CHECK: %[[VAL_39:.*]] = arith.addf %[[VAL_37]], %[[VAL_38]] : f32 ! CHECK: %[[VAL_45:.*]] = arith.addf %[[VAL_38]], %[[VAL_44]] : f32
! CHECK: %[[VAL_40:.*]] = arith.constant 1 : index ! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index
! CHECK-DAG: %[[VAL_41:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32> ! CHECK: %[[VAL_47:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
! CHECK-DAG: %[[VAL_42:.*]] = arith.constant 1 : i32 ! CHECK: %[[VAL_48:.*]] = arith.constant 1 : i32
! CHECK: %[[VAL_43:.*]] = arith.addi %[[VAL_41]], %[[VAL_42]] : i32 ! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_47]], %[[VAL_48]] : i32
! CHECK: %[[VAL_44:.*]] = fir.convert %[[VAL_43]] : (i32) -> i64 ! CHECK: %[[VAL_50:.*]] = fir.convert %[[VAL_49]] : (i32) -> i64
! CHECK: %[[VAL_45:.*]] = fir.convert %[[VAL_44]] : (i64) -> index ! CHECK: %[[VAL_51:.*]] = fir.convert %[[VAL_50]] : (i64) -> index
! CHECK: %[[VAL_46:.*]] = arith.subi %[[VAL_45]], %[[VAL_40]] : index ! CHECK: %[[VAL_52:.*]] = arith.subi %[[VAL_51]], %[[VAL_46]] : index
! CHECK: %[[VAL_47:.*]] = fir.array_update %[[VAL_25]], %[[VAL_39]], %[[VAL_46]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32> ! CHECK: %[[VAL_53:.*]] = fir.array_update %[[VAL_31]], %[[VAL_45]], %[[VAL_52]] : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
! CHECK: fir.result %[[VAL_47]] : !fir.array<?xf32> ! CHECK: fir.result %[[VAL_53]] : !fir.array<?xf32>
! CHECK: } ! CHECK: }
! CHECK: fir.array_merge_store %[[VAL_18]], %[[VAL_48:.*]] to %[[VAL_0]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>> ! CHECK: fir.array_merge_store %[[VAL_24]], %[[VAL_54:.*]] to %[[VAL_0]] : !fir.array<?xf32>, !fir.array<?xf32>, !fir.ref<!fir.array<?xf32>>
! CHECK: return ! CHECK: return
! CHECK: } ! CHECK: }