[llvm-branch-commits] [flang] [flang] optimize array function calls using hlfir.eval_in_mem (PR #118070)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Nov 29 00:59:15 PST 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: None (jeanPerier)
<details>
<summary>Changes</summary>
This patch encapsulate array function call lowering into hlfir.eval_in_mem and allows directly evaluating the call into the LHS when possible.
The conditions are: LHS is contiguous, not accessed inside the function, it is not a whole allocatable, and the function results needs not to be finalized. All these conditions are tested in the previous [hlfir.eval_in_mem optimization patch](https://github.com/llvm/llvm-project/pull/118069) that is leveraging [the extension of getModRef to handle function calls](https://github.com/llvm/llvm-project/pull/117164)).
This yields a 25% speed-up on polyhedron channel2 benchmark (from 1min to 45s measured on an X86-64 Zen 2).
---
Patch is 34.18 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/118070.diff
12 Files Affected:
- (modified) flang/include/flang/Lower/ConvertCall.h (+5-1)
- (modified) flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h (+4)
- (modified) flang/lib/Lower/ConvertCall.cpp (+69-33)
- (modified) flang/lib/Lower/ConvertExpr.cpp (+8-5)
- (modified) flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp (+15)
- (modified) flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp (+1-10)
- (modified) flang/test/HLFIR/order_assignments/where-scheduling.f90 (+1-1)
- (added) flang/test/Lower/HLFIR/calls-array-results.f90 (+131)
- (modified) flang/test/Lower/HLFIR/where-nonelemental.f90 (+21-17)
- (modified) flang/test/Lower/explicit-interface-results-2.f90 (-2)
- (modified) flang/test/Lower/explicit-interface-results.f90 (+4-4)
- (modified) flang/test/Lower/forall/array-constructor.f90 (+1-1)
``````````diff
diff --git a/flang/include/flang/Lower/ConvertCall.h b/flang/include/flang/Lower/ConvertCall.h
index bc082907e61760..2c51a887010c87 100644
--- a/flang/include/flang/Lower/ConvertCall.h
+++ b/flang/include/flang/Lower/ConvertCall.h
@@ -24,6 +24,10 @@
namespace Fortran::lower {
+struct LoweredResult {
+ std::variant<fir::ExtendedValue, hlfir::EntityWithAttributes> result;
+};
+
/// Given a call site for which the arguments were already lowered, generate
/// the call and return the result. This function deals with explicit result
/// allocation and lowering if needed. It also deals with passing the host
@@ -32,7 +36,7 @@ namespace Fortran::lower {
/// It is only used for HLFIR.
/// The returned boolean indicates if finalization has been emitted in
/// \p stmtCtx for the result.
-std::pair<fir::ExtendedValue, bool> genCallOpAndResult(
+std::pair<LoweredResult, bool> genCallOpAndResult(
mlir::Location loc, Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx,
Fortran::lower::CallerInterface &caller, mlir::FunctionType callSiteType,
diff --git a/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h b/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
index 3830237f96f3cc..447d5fbab89998 100644
--- a/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
+++ b/flang/include/flang/Optimizer/HLFIR/HLFIRDialect.h
@@ -61,6 +61,10 @@ inline mlir::Type getFortranElementOrSequenceType(mlir::Type type) {
return type;
}
+/// Build the hlfir.expr type for the value held in a variable of type \p
+/// variableType.
+mlir::Type getExprType(mlir::Type variableType);
+
/// Is this a fir.box or fir.class address type?
inline bool isBoxAddressType(mlir::Type type) {
type = fir::dyn_cast_ptrEleTy(type);
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index e84e7afbe82e09..088d8f96caa410 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -284,7 +284,8 @@ static void remapActualToDummyDescriptors(
}
}
-std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
+std::pair<Fortran::lower::LoweredResult, bool>
+Fortran::lower::genCallOpAndResult(
mlir::Location loc, Fortran::lower::AbstractConverter &converter,
Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx,
Fortran::lower::CallerInterface &caller, mlir::FunctionType callSiteType,
@@ -326,6 +327,11 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
}
}
+ const bool isExprCall =
+ converter.getLoweringOptions().getLowerToHighLevelFIR() &&
+ callSiteType.getNumResults() == 1 &&
+ llvm::isa<fir::SequenceType>(callSiteType.getResult(0));
+
mlir::IndexType idxTy = builder.getIndexType();
auto lowerSpecExpr = [&](const auto &expr) -> mlir::Value {
mlir::Value convertExpr = builder.createConvert(
@@ -333,6 +339,8 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
return fir::factory::genMaxWithZero(builder, loc, convertExpr);
};
llvm::SmallVector<mlir::Value> resultLengths;
+ mlir::Value arrayResultShape;
+ hlfir::EvaluateInMemoryOp evaluateInMemory;
auto allocatedResult = [&]() -> std::optional<fir::ExtendedValue> {
llvm::SmallVector<mlir::Value> extents;
llvm::SmallVector<mlir::Value> lengths;
@@ -366,6 +374,18 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
resultLengths = lengths;
}
+ if (!extents.empty())
+ arrayResultShape = builder.genShape(loc, extents);
+
+ if (isExprCall) {
+ mlir::Type exprType = hlfir::getExprType(type);
+ evaluateInMemory = builder.create<hlfir::EvaluateInMemoryOp>(
+ loc, exprType, arrayResultShape, resultLengths);
+ builder.setInsertionPointToStart(&evaluateInMemory.getBody().front());
+ return toExtendedValue(loc, evaluateInMemory.getMemory(), extents,
+ lengths);
+ }
+
if ((!extents.empty() || !lengths.empty()) && !isElemental) {
// Note: in the elemental context, the alloca ownership inside the
// elemental region is implicit, and later pass in lowering (stack
@@ -384,8 +404,7 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
if (mustPopSymMap)
symMap.popScope();
- // Place allocated result or prepare the fir.save_result arguments.
- mlir::Value arrayResultShape;
+ // Place allocated result
if (allocatedResult) {
if (std::optional<Fortran::lower::CallInterface<
Fortran::lower::CallerInterface>::PassedEntity>
@@ -399,16 +418,6 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
else
fir::emitFatalError(
loc, "only expect character scalar result to be passed by ref");
- } else {
- assert(caller.mustSaveResult());
- arrayResultShape = allocatedResult->match(
- [&](const fir::CharArrayBoxValue &) {
- return builder.createShape(loc, *allocatedResult);
- },
- [&](const fir::ArrayBoxValue &) {
- return builder.createShape(loc, *allocatedResult);
- },
- [&](const auto &) { return mlir::Value{}; });
}
}
@@ -642,6 +651,19 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
callResult = call.getResult(0);
}
+ std::optional<Fortran::evaluate::DynamicType> retTy =
+ caller.getCallDescription().proc().GetType();
+ // With HLFIR lowering, isElemental must be set to true
+ // if we are producing an elemental call. In this case,
+ // the elemental results must not be destroyed, instead,
+ // the resulting array result will be finalized/destroyed
+ // as needed by hlfir.destroy.
+ const bool mustFinalizeResult =
+ !isElemental && callSiteType.getNumResults() > 0 &&
+ !fir::isPointerType(callSiteType.getResult(0)) && retTy.has_value() &&
+ (retTy->category() == Fortran::common::TypeCategory::Derived ||
+ retTy->IsPolymorphic() || retTy->IsUnlimitedPolymorphic());
+
if (caller.mustSaveResult()) {
assert(allocatedResult.has_value());
builder.create<fir::SaveResultOp>(loc, callResult,
@@ -649,6 +671,19 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
arrayResultShape, resultLengths);
}
+ if (evaluateInMemory) {
+ builder.setInsertionPointAfter(evaluateInMemory);
+ mlir::Value expr = evaluateInMemory.getResult();
+ fir::FirOpBuilder *bldr = &converter.getFirOpBuilder();
+ if (!isElemental)
+ stmtCtx.attachCleanup([bldr, loc, expr, mustFinalizeResult]() {
+ bldr->create<hlfir::DestroyOp>(loc, expr,
+ /*finalize=*/mustFinalizeResult);
+ });
+ return {LoweredResult{hlfir::EntityWithAttributes{expr}},
+ mustFinalizeResult};
+ }
+
if (allocatedResult) {
// The result must be optionally destroyed (if it is of a derived type
// that may need finalization or deallocation of the components).
@@ -679,17 +714,7 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
// derived-type.
// For polymorphic and unlimited polymorphic enities call the runtime
// in any cases.
- std::optional<Fortran::evaluate::DynamicType> retTy =
- caller.getCallDescription().proc().GetType();
- // With HLFIR lowering, isElemental must be set to true
- // if we are producing an elemental call. In this case,
- // the elemental results must not be destroyed, instead,
- // the resulting array result will be finalized/destroyed
- // as needed by hlfir.destroy.
- if (!isElemental && !fir::isPointerType(funcType.getResults()[0]) &&
- retTy &&
- (retTy->category() == Fortran::common::TypeCategory::Derived ||
- retTy->IsPolymorphic() || retTy->IsUnlimitedPolymorphic())) {
+ if (mustFinalizeResult) {
if (retTy->IsPolymorphic() || retTy->IsUnlimitedPolymorphic()) {
auto *bldr = &converter.getFirOpBuilder();
stmtCtx.attachCleanup([bldr, loc, allocatedResult]() {
@@ -715,12 +740,13 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
}
}
}
- return {*allocatedResult, resultIsFinalized};
+ return {LoweredResult{*allocatedResult}, resultIsFinalized};
}
// subroutine call
if (!resultType)
- return {fir::ExtendedValue{mlir::Value{}}, /*resultIsFinalized=*/false};
+ return {LoweredResult{fir::ExtendedValue{mlir::Value{}}},
+ /*resultIsFinalized=*/false};
// For now, Fortran return values are implemented with a single MLIR
// function return value.
@@ -734,10 +760,13 @@ std::pair<fir::ExtendedValue, bool> Fortran::lower::genCallOpAndResult(
mlir::dyn_cast<fir::CharacterType>(funcType.getResults()[0]);
mlir::Value len = builder.createIntegerConstant(
loc, builder.getCharacterLengthType(), charTy.getLen());
- return {fir::CharBoxValue{callResult, len}, /*resultIsFinalized=*/false};
+ return {
+ LoweredResult{fir::ExtendedValue{fir::CharBoxValue{callResult, len}}},
+ /*resultIsFinalized=*/false};
}
- return {callResult, /*resultIsFinalized=*/false};
+ return {LoweredResult{fir::ExtendedValue{callResult}},
+ /*resultIsFinalized=*/false};
}
static hlfir::EntityWithAttributes genStmtFunctionRef(
@@ -1661,19 +1690,26 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
// Prepare lowered arguments according to the interface
// and map the lowered values to the dummy
// arguments.
- auto [result, resultIsFinalized] = Fortran::lower::genCallOpAndResult(
+ auto [loweredResult, resultIsFinalized] = Fortran::lower::genCallOpAndResult(
loc, callContext.converter, callContext.symMap, callContext.stmtCtx,
caller, callSiteType, callContext.resultType,
callContext.isElementalProcWithArrayArgs());
- // For procedure pointer function result, just return the call.
- if (callContext.resultType &&
- mlir::isa<fir::BoxProcType>(*callContext.resultType))
- return hlfir::EntityWithAttributes(fir::getBase(result));
/// Clean-up associations and copy-in.
for (auto cleanUp : callCleanUps)
cleanUp.genCleanUp(loc, builder);
+ if (auto *entity =
+ std::get_if<hlfir::EntityWithAttributes>(&loweredResult.result))
+ return *entity;
+
+ auto &result = std::get<fir::ExtendedValue>(loweredResult.result);
+
+ // For procedure pointer function result, just return the call.
+ if (callContext.resultType &&
+ mlir::isa<fir::BoxProcType>(*callContext.resultType))
+ return hlfir::EntityWithAttributes(fir::getBase(result));
+
if (!fir::getBase(result))
return std::nullopt; // subroutine call.
diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp
index 46168b81dd3a03..926e45b807e0a0 100644
--- a/flang/lib/Lower/ConvertExpr.cpp
+++ b/flang/lib/Lower/ConvertExpr.cpp
@@ -2852,10 +2852,11 @@ class ScalarExprLowering {
}
}
- ExtValue result =
+ auto loweredResult =
Fortran::lower::genCallOpAndResult(loc, converter, symMap, stmtCtx,
caller, callSiteType, resultType)
.first;
+ auto &result = std::get<ExtValue>(loweredResult.result);
// Sync pointers and allocatables that may have been modified during the
// call.
@@ -4881,10 +4882,12 @@ class ArrayExprLowering {
[&](const auto &) { return fir::getBase(exv); });
caller.placeInput(argIface, arg);
}
- return Fortran::lower::genCallOpAndResult(loc, converter, symMap,
- getElementCtx(), caller,
- callSiteType, retTy)
- .first;
+ Fortran::lower::LoweredResult res =
+ Fortran::lower::genCallOpAndResult(loc, converter, symMap,
+ getElementCtx(), caller,
+ callSiteType, retTy)
+ .first;
+ return std::get<ExtValue>(res.result);
};
}
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
index 0b61c0edce622b..c66ba75f912fb7 100644
--- a/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
+++ b/flang/lib/Optimizer/HLFIR/IR/HLFIRDialect.cpp
@@ -215,3 +215,18 @@ bool hlfir::mayHaveAllocatableComponent(mlir::Type ty) {
return fir::isPolymorphicType(ty) || fir::isUnlimitedPolymorphicType(ty) ||
fir::isRecordWithAllocatableMember(hlfir::getFortranElementType(ty));
}
+
+mlir::Type hlfir::getExprType(mlir::Type variableType) {
+ hlfir::ExprType::Shape typeShape;
+ bool isPolymorphic = fir::isPolymorphicType(variableType);
+ mlir::Type type = getFortranElementOrSequenceType(variableType);
+ assert(!fir::isa_trivial(type) &&
+ "numerical and logical scalar should not be wrapped in hlfir.expr");
+ if (auto seqType = mlir::dyn_cast<fir::SequenceType>(type)) {
+ assert(!seqType.hasUnknownShape() && "assumed-rank cannot be expressions");
+ typeShape.append(seqType.getShape().begin(), seqType.getShape().end());
+ type = seqType.getEleTy();
+ }
+ return hlfir::ExprType::get(variableType.getContext(), typeShape, type,
+ isPolymorphic);
+}
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
index 87519882446485..3a172d1b8b5400 100644
--- a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
+++ b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
@@ -1427,16 +1427,7 @@ llvm::LogicalResult hlfir::EndAssociateOp::verify() {
void hlfir::AsExprOp::build(mlir::OpBuilder &builder,
mlir::OperationState &result, mlir::Value var,
mlir::Value mustFree) {
- hlfir::ExprType::Shape typeShape;
- bool isPolymorphic = fir::isPolymorphicType(var.getType());
- mlir::Type type = getFortranElementOrSequenceType(var.getType());
- if (auto seqType = mlir::dyn_cast<fir::SequenceType>(type)) {
- typeShape.append(seqType.getShape().begin(), seqType.getShape().end());
- type = seqType.getEleTy();
- }
-
- auto resultType = hlfir::ExprType::get(builder.getContext(), typeShape, type,
- isPolymorphic);
+ mlir::Type resultType = hlfir::getExprType(var.getType());
return build(builder, result, resultType, var, mustFree);
}
diff --git a/flang/test/HLFIR/order_assignments/where-scheduling.f90 b/flang/test/HLFIR/order_assignments/where-scheduling.f90
index 3010476d4a188f..6feaba0d3389a0 100644
--- a/flang/test/HLFIR/order_assignments/where-scheduling.f90
+++ b/flang/test/HLFIR/order_assignments/where-scheduling.f90
@@ -134,7 +134,7 @@ end function f
!CHECK-NEXT: run 1 save : where/mask
!CHECK-NEXT: run 2 evaluate: where/region_assign1
!CHECK-LABEL: ------------ scheduling where in _QPonly_once ------------
-!CHECK-NEXT: unknown effect: %{{[0-9]+}} = llvm.intr.stacksave : !llvm.ptr
+!CHECK-NEXT: unknown effect: %11 = fir.call @_QPcall_me_only_once() fastmath<contract> : () -> !fir.array<10x!fir.logical<4>>
!CHECK-NEXT: saving eval because write effect prevents re-evaluation
!CHECK-NEXT: run 1 save (w): where/mask
!CHECK-NEXT: run 2 evaluate: where/region_assign1
diff --git a/flang/test/Lower/HLFIR/calls-array-results.f90 b/flang/test/Lower/HLFIR/calls-array-results.f90
new file mode 100644
index 00000000000000..d91844cc2e6f87
--- /dev/null
+++ b/flang/test/Lower/HLFIR/calls-array-results.f90
@@ -0,0 +1,131 @@
+! RUN: bbc -emit-hlfir -o - %s -I nowhere | FileCheck %s
+
+subroutine simple_test()
+ implicit none
+ interface
+ function array_func()
+ real :: array_func(10)
+ end function
+ end interface
+ real :: x(10)
+ x = array_func()
+end subroutine
+
+subroutine arg_test(n)
+ implicit none
+ interface
+ function array_func_2(n)
+ integer(8) :: n
+ real :: array_func_2(n)
+ end function
+ end interface
+ integer(8) :: n
+ real :: x(n)
+ x = array_func_2(n)
+end subroutine
+
+module type_defs
+ interface
+ function array_func()
+ real :: array_func(10)
+ end function
+ end interface
+ type t
+ contains
+ procedure, nopass :: array_func => array_func
+ end type
+end module
+
+subroutine dispatch_test(x, a)
+ use type_defs, only : t
+ implicit none
+ real :: x(10)
+ class(t) :: a
+ x = a%array_func()
+end subroutine
+
+! CHECK-LABEL: func.func @_QPsimple_test() {
+! CHECK: %[[VAL_0:.*]] = arith.constant 10 : index
+! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.array<10xf32> {bindc_name = "x", uniq_name = "_QFsimple_testEx"}
+! CHECK: %[[VAL_2:.*]] = fir.shape %[[VAL_0]] : (index) -> !fir.shape<1>
+! CHECK: %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_1]](%[[VAL_2]]) {uniq_name = "_QFsimple_testEx"} : (!fir.ref<!fir.array<10xf32>>, !fir.shape<1>) -> (!fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>)
+! CHECK: %[[VAL_4:.*]] = arith.constant 10 : i64
+! CHECK: %[[VAL_5:.*]] = arith.constant 1 : i64
+! CHECK: %[[VAL_6:.*]] = arith.subi %[[VAL_4]], %[[VAL_5]] : i64
+! CHECK: %[[VAL_7:.*]] = arith.constant 1 : i64
+! CHECK: %[[VAL_8:.*]] = arith.addi %[[VAL_6]], %[[VAL_7]] : i64
+! CHECK: %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i64) -> index
+! CHECK: %[[VAL_10:.*]] = arith.constant 0 : index
+! CHECK: %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_9]], %[[VAL_10]] : index
+! CHECK: %[[VAL_12:.*]] = arith.select %[[VAL_11]], %[[VAL_9]], %[[VAL_10]] : index
+! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1>
+! CHECK: %[[VAL_14:.*]] = hlfir.eval_in_mem shape %[[VAL_13]] : (!fir.shape<1>) -> !hlfir.expr<10xf32> {
+! CHECK: ^bb0(%[[VAL_15:.*]]: !fir.ref<!fir.array<10xf32>>):
+! CHECK: %[[VAL_16:.*]] = fir.call @_QParray_func() fastmath<contract> : () -> !fir.array<10xf32>
+! CHECK: fir.save_result %[[VAL_16]] to %[[VAL_15]](%[[VAL_13]]) : !fir.array<10xf32>, !fir.ref<!fir.array<10xf32>>, !fir.shape<1>
+! CHECK: }
+! CHECK: hlfir.assign %[[VAL_14]] to %[[VAL_3]]#0 : !hlfir.expr<10xf32>, !fir.ref<!fir.array<10xf32>>
+! CHECK: hlfir.destroy %[[VAL_14]] : !hlfir.expr<10xf32>
+! CHECK: return
+! CHECK: }
+
+! CHECK-LABEL: func.func @_QParg_test(
+! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<i64> {fir.bindc_name = "n"}) {
+! CHECK: %[[VAL_1:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[VAL_2:.*]]:2 = hlfir.declare %[[VAL_0]] dummy_scope %[[VAL_1]] {uniq_name = "_QFarg_testEn"} : (!fir.ref<i64>, !fir.dscope) -> (!fir.ref<i64>, !fir.ref<i64>)
+! CHECK: %[[VAL_3:.*]] = fir.load %[[VAL_2]]#0 : !fir.ref<i64>
+! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_3]] : (i64) -> index
+! CHECK: %[[VAL_5:.*]] = arith.constant 0 : index
+! CHECK: %[[VAL_6:.*]] = arith.cmpi sgt, %[[VAL_4]], %[[VAL_5]] : index
+! CHECK: %[[VAL_7:.*]] = arith.select %[[VAL_6]], %[[VAL_4]], %[[VAL_5]] : index
+! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.array<?xf32>, %[[VAL_7]] {bindc_name = "x", uniq_name = "_QFarg_testEx"}
+! CHECK: %[[VAL_9:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
+! CHECK: %[[VAL_10:.*]]:2 = hlfir.declare %[[VAL_8]](%[[VAL_9]]) {uniq_name = "_QFarg_testEx"} : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xf32>>, !fir.ref<!fir.array<?xf32>>)
+! CHECK: %[[VAL_11:.*]]:2 = hlfir.declare %[[VAL_2]]#1 {uniq_name = "_QFarg_testFarray_func_2En"} : (!fir.ref<i64>) -> (!fir.ref<i64>, !fir.ref<i64>)
+! CHECK: %[[VAL_12:.*]] = fir.load %[[VAL_11]]#0 : !fir.ref<i64>
+! CHECK: %[[VAL_13:.*]] = arith.constant 1 : i64
+! CHECK: %[[VAL_14:.*]] = arith.subi %[[VAL_12]], %[[VAL_13]] : i64
+! CHECK: %[[VAL_15:.*]] = arith.constant 1 : i64
+! CHECK: %[[VAL_16:.*]] = arith.addi %[[VAL_14]], %[[VAL_15]] : i64
+! CHECK: %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i64) -> index
+! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index
+! CHECK: %[[VAL_19:.*]] = arith.cmpi sgt, %...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/118070
More information about the llvm-branch-commits
mailing list