[flang-commits] [flang] [flang] Do not move finalized function results in lowering (PR #80683)
via flang-commits
flang-commits at lists.llvm.org
Tue Feb 6 07:51:57 PST 2024
https://github.com/jeanPerier updated https://github.com/llvm/llvm-project/pull/80683
>From ff53e601ea204f061ba96e61eaeeab8d6ff46402 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier at nvidia.com>
Date: Mon, 5 Feb 2024 06:05:05 -0800
Subject: [PATCH 1/3] [flang] Do not move finalized function result in lowering
Fortran requires finalizing function results when the result type
have final procedures.
Lowering was unconditionally "moving" function results into values
"hlfir.expr". This is not correct when the results are finalized because
it means the function result storage will be used after the hlfir.expr.
Only move function results that are not finalized.
---
flang/include/flang/Lower/ConvertCall.h | 4 +-
flang/lib/Lower/ConvertCall.cpp | 40 ++++++++++++-------
flang/lib/Lower/ConvertExpr.cpp | 12 ++++--
.../Lower/HLFIR/function-return-as-expr.f90 | 7 ++--
4 files changed, 41 insertions(+), 22 deletions(-)
diff --git a/flang/include/flang/Lower/ConvertCall.h b/flang/include/flang/Lower/ConvertCall.h
index f8171236bb39d..bc082907e6176 100644
--- a/flang/include/flang/Lower/ConvertCall.h
+++ b/flang/include/flang/Lower/ConvertCall.h
@@ -30,7 +30,9 @@ namespace Fortran::lower {
/// link to internal procedures.
/// \p isElemental must be set to true if elemental call is being produced.
/// It is only used for HLFIR.
-fir::ExtendedValue genCallOpAndResult(
+/// The returned boolean indicates if finalization has been emitted in
+/// \p stmtCtx for the result.
+std::pair<fir::ExtendedValue, 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/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index bb8fd2e945f43..b10a51229a082 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -147,7 +147,7 @@ static bool mustCastFuncOpToCopeWithImplicitInterfaceMismatch(
return false;
}
-fir::ExtendedValue Fortran::lower::genCallOpAndResult(
+std::pair<fir::ExtendedValue, 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,
@@ -478,6 +478,7 @@ fir::ExtendedValue Fortran::lower::genCallOpAndResult(
[](const auto &) {});
// 7.5.6.3 point 5. Derived-type finalization for nonpointer function.
+ bool resultIsFinalized = false;
// Check if the derived-type is finalizable if it is a monomorphic
// derived-type.
// For polymorphic and unlimited polymorphic enities call the runtime
@@ -499,6 +500,7 @@ fir::ExtendedValue Fortran::lower::genCallOpAndResult(
fir::runtime::genDerivedTypeDestroy(*bldr, loc,
fir::getBase(*allocatedResult));
});
+ resultIsFinalized = true;
} else {
const Fortran::semantics::DerivedTypeSpec &typeSpec =
retTy->GetDerivedTypeSpec();
@@ -513,14 +515,17 @@ fir::ExtendedValue Fortran::lower::genCallOpAndResult(
mlir::Value box = bldr->createBox(loc, *allocatedResult);
fir::runtime::genDerivedTypeDestroy(*bldr, loc, box);
});
+ resultIsFinalized = true;
}
}
}
- return *allocatedResult;
+ return {*allocatedResult, resultIsFinalized};
}
+ // subroutine call
if (!resultType)
- return mlir::Value{}; // subroutine call
+ return {fir::ExtendedValue{mlir::Value{}}, /*resultIsFinalized=*/false};
+
// For now, Fortran return values are implemented with a single MLIR
// function return value.
assert(callNumResults == 1 && "Expected exactly one result in FUNCTION call");
@@ -533,10 +538,10 @@ fir::ExtendedValue Fortran::lower::genCallOpAndResult(
funcType.getResults()[0].dyn_cast<fir::CharacterType>();
mlir::Value len = builder.createIntegerConstant(
loc, builder.getCharacterLengthType(), charTy.getLen());
- return fir::CharBoxValue{callResult, len};
+ return {fir::CharBoxValue{callResult, len}, /*resultIsFinalized=*/false};
}
- return callResult;
+ return {callResult, /*resultIsFinalized=*/false};
}
static hlfir::EntityWithAttributes genStmtFunctionRef(
@@ -1389,7 +1394,7 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
// Prepare lowered arguments according to the interface
// and map the lowered values to the dummy
// arguments.
- fir::ExtendedValue result = Fortran::lower::genCallOpAndResult(
+ auto [result, resultIsFinalized] = Fortran::lower::genCallOpAndResult(
loc, callContext.converter, callContext.symMap, callContext.stmtCtx,
caller, callSiteType, callContext.resultType,
callContext.isElementalProcWithArrayArgs());
@@ -1409,15 +1414,22 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
if (!fir::isPointerType(fir::getBase(result).getType())) {
resultEntity = loadTrivialScalar(loc, builder, resultEntity);
-
if (resultEntity.isVariable()) {
- // Function result must not be freed, since it is allocated on the stack.
- // Note that in non-elemental case, genCallOpAndResult()
- // is responsible for establishing the clean-up that destroys
- // the derived type result or deallocates its components
- // without finalization.
- auto asExpr = builder.create<hlfir::AsExprOp>(
- loc, resultEntity, /*mustFree=*/builder.createBool(loc, false));
+ // If the result has no finalization, it can be moved into an expression.
+ // In such case, the expression should not be freed after its use since
+ // the result is stack allocated or deallocation (for allocatable results)
+ // was already inserted in genCallOpAndResult.
+ // If the result has finalization, it cannot be moved because use of its
+ // value have been created in the statement context and may be emitted
+ // after the hlfir.expr destroy.
+ // TODO: find a way to move the finalization on the hlfir.expr to avoid a
+ // copy. This is likely better done in a pass since it is not clear here
+ // when an where the hlfir.destroy or hlfir.end_associate will be emitted
+ // for the expression.
+ mlir::Value mustFree =
+ resultIsFinalized ? mlir::Value{} : builder.createBool(loc, false);
+ auto asExpr = builder.create<hlfir::AsExprOp>(loc, resultEntity,
+ /*mustFree=*/mustFree);
resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
}
}
diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp
index a2b28aa2e0491..d157db2cde496 100644
--- a/flang/lib/Lower/ConvertExpr.cpp
+++ b/flang/lib/Lower/ConvertExpr.cpp
@@ -2846,8 +2846,10 @@ class ScalarExprLowering {
}
}
- ExtValue result = Fortran::lower::genCallOpAndResult(
- loc, converter, symMap, stmtCtx, caller, callSiteType, resultType);
+ ExtValue result =
+ Fortran::lower::genCallOpAndResult(loc, converter, symMap, stmtCtx,
+ caller, callSiteType, resultType)
+ .first;
// Sync pointers and allocatables that may have been modified during the
// call.
@@ -4866,8 +4868,10 @@ class ArrayExprLowering {
[&](const auto &) { return fir::getBase(exv); });
caller.placeInput(argIface, arg);
}
- return Fortran::lower::genCallOpAndResult(
- loc, converter, symMap, getElementCtx(), caller, callSiteType, retTy);
+ return Fortran::lower::genCallOpAndResult(loc, converter, symMap,
+ getElementCtx(), caller,
+ callSiteType, retTy)
+ .first;
};
}
diff --git a/flang/test/Lower/HLFIR/function-return-as-expr.f90 b/flang/test/Lower/HLFIR/function-return-as-expr.f90
index 7c8e73779d79e..dadb9f7c96478 100644
--- a/flang/test/Lower/HLFIR/function-return-as-expr.f90
+++ b/flang/test/Lower/HLFIR/function-return-as-expr.f90
@@ -66,11 +66,12 @@ function inner()
end function inner
end subroutine test4
! CHECK-LABEL: func.func @_QPtest4() {
-! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.class<!fir.heap<none>>>) -> (!fir.ref<!fir.class<!fir.heap<none>>>, !fir.ref<!fir.class<!fir.heap<none>>>)
+! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_0:.*]] {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.class<!fir.heap<none>>>) -> (!fir.ref<!fir.class<!fir.heap<none>>>, !fir.ref<!fir.class<!fir.heap<none>>>)
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref<!fir.class<!fir.heap<none>>>
-! CHECK: %[[VAL_8:.*]] = arith.constant false
-! CHECK: %[[VAL_9:.*]] = hlfir.as_expr %[[VAL_7]] move %[[VAL_8]] : (!fir.class<!fir.heap<none>>, i1) -> !hlfir.expr<none?>
+! CHECK: %[[VAL_9:.*]] = hlfir.as_expr %[[VAL_7]] : (!fir.class<!fir.heap<none>>) -> !hlfir.expr<none?>
! CHECK: hlfir.assign %[[VAL_9]] to %{{.*}}#0 realloc : !hlfir.expr<none?>, !fir.ref<!fir.class<!fir.heap<none>>>
+! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.class<!fir.heap<none>>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranADestroy(%[[VAL_10]]) fastmath<contract> : (!fir.box<none>) -> none
subroutine test5
use types
>From e6584d2a8758f9c6f3f228b6775a8bd86c85fd5c Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier at nvidia.com>
Date: Tue, 6 Feb 2024 03:31:14 -0800
Subject: [PATCH 2/3] Update to not emit hlfir.as_expr if it is not a move
My previous approach was semantically correct, but it is creating
temporaries in many cases where they are not needed like "call foo(bar())"
where bar() return a CLASS(T). Bar result can be forwarded, while this
hlfir.as_expr implied a copy.
Simply do not promote result variables to hlfir.expr if this cannot be
done with a "move". Promoting to hlfir.expr is meant to help HLFIR
pass deducing that the result value cannot change/do not alias, but
it it cost a copy to do this, this is simply not worth it.
---
flang/lib/Lower/ConvertCall.cpp | 18 ++++++++----------
.../Lower/HLFIR/function-return-as-expr.f90 | 3 +--
2 files changed, 9 insertions(+), 12 deletions(-)
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index b10a51229a082..f1a3e896740c7 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -1414,22 +1414,20 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
if (!fir::isPointerType(fir::getBase(result).getType())) {
resultEntity = loadTrivialScalar(loc, builder, resultEntity);
- if (resultEntity.isVariable()) {
+ if (!resultIsFinalized && resultEntity.isVariable()) {
// If the result has no finalization, it can be moved into an expression.
// In such case, the expression should not be freed after its use since
// the result is stack allocated or deallocation (for allocatable results)
// was already inserted in genCallOpAndResult.
// If the result has finalization, it cannot be moved because use of its
// value have been created in the statement context and may be emitted
- // after the hlfir.expr destroy.
- // TODO: find a way to move the finalization on the hlfir.expr to avoid a
- // copy. This is likely better done in a pass since it is not clear here
- // when an where the hlfir.destroy or hlfir.end_associate will be emitted
- // for the expression.
- mlir::Value mustFree =
- resultIsFinalized ? mlir::Value{} : builder.createBool(loc, false);
- auto asExpr = builder.create<hlfir::AsExprOp>(loc, resultEntity,
- /*mustFree=*/mustFree);
+ // after the hlfir.expr destroy, so the result is kept as a variable in
+ // HLFIR. This may lead to copies when passing the result to an argument
+ // with VALUE, and this do not convey the fact that the result will not
+ // change, but is correct, and using hlfir.expr without the move would
+ // trigger a copy that may be avoided.
+ auto asExpr = builder.create<hlfir::AsExprOp>(
+ loc, resultEntity, /*mustFree=*/builder.createBool(loc, false));
resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
}
}
diff --git a/flang/test/Lower/HLFIR/function-return-as-expr.f90 b/flang/test/Lower/HLFIR/function-return-as-expr.f90
index dadb9f7c96478..3f9db0bed6c12 100644
--- a/flang/test/Lower/HLFIR/function-return-as-expr.f90
+++ b/flang/test/Lower/HLFIR/function-return-as-expr.f90
@@ -68,8 +68,7 @@ end subroutine test4
! CHECK-LABEL: func.func @_QPtest4() {
! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_0:.*]] {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.class<!fir.heap<none>>>) -> (!fir.ref<!fir.class<!fir.heap<none>>>, !fir.ref<!fir.class<!fir.heap<none>>>)
! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref<!fir.class<!fir.heap<none>>>
-! CHECK: %[[VAL_9:.*]] = hlfir.as_expr %[[VAL_7]] : (!fir.class<!fir.heap<none>>) -> !hlfir.expr<none?>
-! CHECK: hlfir.assign %[[VAL_9]] to %{{.*}}#0 realloc : !hlfir.expr<none?>, !fir.ref<!fir.class<!fir.heap<none>>>
+! CHECK: hlfir.assign %[[VAL_7]] to %{{.*}}#0 realloc : !fir.class<!fir.heap<none>>, !fir.ref<!fir.class<!fir.heap<none>>>
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.class<!fir.heap<none>>>) -> !fir.box<none>
! CHECK: fir.call @_FortranADestroy(%[[VAL_10]]) fastmath<contract> : (!fir.box<none>) -> none
>From 7316a5d88bf5e3cec68b9847a071957849c14fec Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier at nvidia.com>
Date: Tue, 6 Feb 2024 07:46:16 -0800
Subject: [PATCH 3/3] Drop allocatable result lower bounds when not using
hlfir.as_expr
Allocatable results do not have lower bounds, move the hlfir.declare
after the load to cover this case (previously the hlfir.as_expr had this
effect).
---
.../flang/Optimizer/Builder/MutableBox.h | 3 +-
flang/lib/Lower/ConvertCall.cpp | 42 +++++++++++++------
flang/lib/Optimizer/Builder/MutableBox.cpp | 8 +++-
.../Lower/HLFIR/function-return-as-expr.f90 | 21 ++++++++--
4 files changed, 55 insertions(+), 19 deletions(-)
diff --git a/flang/include/flang/Optimizer/Builder/MutableBox.h b/flang/include/flang/Optimizer/Builder/MutableBox.h
index 8cd8f28dd9a10..0573d2b238c20 100644
--- a/flang/include/flang/Optimizer/Builder/MutableBox.h
+++ b/flang/include/flang/Optimizer/Builder/MutableBox.h
@@ -150,7 +150,8 @@ void syncMutableBoxFromIRBox(fir::FirOpBuilder &builder, mlir::Location loc,
fir::ExtendedValue genMutableBoxRead(fir::FirOpBuilder &builder,
mlir::Location loc,
const fir::MutableBoxValue &box,
- bool mayBePolymorphic = true);
+ bool mayBePolymorphic = true,
+ bool preserveLowerBounds = true);
/// Returns the fir.ref<fir.box<T>> of a MutableBoxValue filled with the current
/// association / allocation properties. If the fir.ref<fir.box> already exists
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
index f1a3e896740c7..f60cdbb690e7c 100644
--- a/flang/lib/Lower/ConvertCall.cpp
+++ b/flang/lib/Lower/ConvertCall.cpp
@@ -42,6 +42,8 @@ static llvm::cl::opt<bool> useHlfirIntrinsicOps(
llvm::cl::desc("Lower via HLFIR transformational intrinsic operations such "
"as hlfir.sum"));
+static constexpr char tempResultName[] = ".tmp.func_result";
+
/// Helper to package a Value and its properties into an ExtendedValue.
static fir::ExtendedValue toExtendedValue(mlir::Location loc, mlir::Value base,
llvm::ArrayRef<mlir::Value> extents,
@@ -1409,29 +1411,43 @@ genUserCall(Fortran::lower::PreparedActualArguments &loweredActuals,
if (!fir::getBase(result))
return std::nullopt; // subroutine call.
- hlfir::Entity resultEntity =
- extendedValueToHlfirEntity(loc, builder, result, ".tmp.func_result");
+ if (fir::isPointerType(fir::getBase(result).getType()))
+ return extendedValueToHlfirEntity(loc, builder, result, tempResultName);
- if (!fir::isPointerType(fir::getBase(result).getType())) {
+ if (!resultIsFinalized) {
+ hlfir::Entity resultEntity =
+ extendedValueToHlfirEntity(loc, builder, result, tempResultName);
resultEntity = loadTrivialScalar(loc, builder, resultEntity);
- if (!resultIsFinalized && resultEntity.isVariable()) {
+ if (resultEntity.isVariable()) {
// If the result has no finalization, it can be moved into an expression.
// In such case, the expression should not be freed after its use since
// the result is stack allocated or deallocation (for allocatable results)
// was already inserted in genCallOpAndResult.
- // If the result has finalization, it cannot be moved because use of its
- // value have been created in the statement context and may be emitted
- // after the hlfir.expr destroy, so the result is kept as a variable in
- // HLFIR. This may lead to copies when passing the result to an argument
- // with VALUE, and this do not convey the fact that the result will not
- // change, but is correct, and using hlfir.expr without the move would
- // trigger a copy that may be avoided.
auto asExpr = builder.create<hlfir::AsExprOp>(
loc, resultEntity, /*mustFree=*/builder.createBool(loc, false));
- resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
+ return hlfir::EntityWithAttributes{asExpr.getResult()};
}
+ return hlfir::EntityWithAttributes{resultEntity};
}
- return hlfir::EntityWithAttributes{resultEntity};
+ // If the result has finalization, it cannot be moved because use of its
+ // value have been created in the statement context and may be emitted
+ // after the hlfir.expr destroy, so the result is kept as a variable in
+ // HLFIR. This may lead to copies when passing the result to an argument
+ // with VALUE, and this do not convey the fact that the result will not
+ // change, but is correct, and using hlfir.expr without the move would
+ // trigger a copy that may be avoided.
+
+ // Load allocatable results before emitting the hlfir.declare and drop its
+ // lower bounds: this is not a variable From the Fortran point of view, so
+ // the lower bounds are ones when inquired on the caller side.
+ const auto *allocatable = result.getBoxOf<fir::MutableBoxValue>();
+ fir::ExtendedValue loadedResult =
+ allocatable
+ ? fir::factory::genMutableBoxRead(builder, loc, *allocatable,
+ /*mayBePolymorphic=*/true,
+ /*preserveLowerBounds=*/false)
+ : result;
+ return extendedValueToHlfirEntity(loc, builder, loadedResult, tempResultName);
}
/// Create an optional dummy argument value from an entity that may be
diff --git a/flang/lib/Optimizer/Builder/MutableBox.cpp b/flang/lib/Optimizer/Builder/MutableBox.cpp
index 61813f6b71dc5..4d8860b60915c 100644
--- a/flang/lib/Optimizer/Builder/MutableBox.cpp
+++ b/flang/lib/Optimizer/Builder/MutableBox.cpp
@@ -406,7 +406,8 @@ static bool readToBoxValue(const fir::MutableBoxValue &box,
fir::ExtendedValue
fir::factory::genMutableBoxRead(fir::FirOpBuilder &builder, mlir::Location loc,
const fir::MutableBoxValue &box,
- bool mayBePolymorphic) {
+ bool mayBePolymorphic,
+ bool preserveLowerBounds) {
if (box.hasAssumedRank())
TODO(loc, "assumed rank allocatables or pointers");
llvm::SmallVector<mlir::Value> lbounds;
@@ -414,7 +415,8 @@ fir::factory::genMutableBoxRead(fir::FirOpBuilder &builder, mlir::Location loc,
llvm::SmallVector<mlir::Value> lengths;
if (readToBoxValue(box, mayBePolymorphic)) {
auto reader = MutablePropertyReader(builder, loc, box);
- reader.getLowerBounds(lbounds);
+ if (preserveLowerBounds)
+ reader.getLowerBounds(lbounds);
return fir::BoxValue{reader.getIrBox(), lbounds,
box.nonDeferredLenParams()};
}
@@ -422,6 +424,8 @@ fir::factory::genMutableBoxRead(fir::FirOpBuilder &builder, mlir::Location loc,
// fir.box.
auto addr =
MutablePropertyReader(builder, loc, box).read(lbounds, extents, lengths);
+ if (!preserveLowerBounds)
+ lbounds.clear();
auto rank = box.rank();
if (box.isCharacter()) {
auto len = lengths.empty() ? mlir::Value{} : lengths[0];
diff --git a/flang/test/Lower/HLFIR/function-return-as-expr.f90 b/flang/test/Lower/HLFIR/function-return-as-expr.f90
index 3f9db0bed6c12..ae4f679a0fe60 100644
--- a/flang/test/Lower/HLFIR/function-return-as-expr.f90
+++ b/flang/test/Lower/HLFIR/function-return-as-expr.f90
@@ -66,12 +66,27 @@ function inner()
end function inner
end subroutine test4
! CHECK-LABEL: func.func @_QPtest4() {
-! CHECK: %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_0:.*]] {uniq_name = ".tmp.func_result"} : (!fir.ref<!fir.class<!fir.heap<none>>>) -> (!fir.ref<!fir.class<!fir.heap<none>>>, !fir.ref<!fir.class<!fir.heap<none>>>)
-! CHECK: %[[VAL_7:.*]] = fir.load %[[VAL_6]]#0 : !fir.ref<!fir.class<!fir.heap<none>>>
-! CHECK: hlfir.assign %[[VAL_7]] to %{{.*}}#0 realloc : !fir.class<!fir.heap<none>>, !fir.ref<!fir.class<!fir.heap<none>>>
+! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0:.*]] : !fir.ref<!fir.class<!fir.heap<none>>>
+! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]] {uniq_name = ".tmp.func_result"} : (!fir.class<!fir.heap<none>>) -> (!fir.class<!fir.heap<none>>, !fir.class<!fir.heap<none>>)
+! CHECK: hlfir.assign %[[VAL_7]]#0 to %{{.*}}#0 realloc : !fir.class<!fir.heap<none>>, !fir.ref<!fir.class<!fir.heap<none>>>
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.class<!fir.heap<none>>>) -> !fir.box<none>
! CHECK: fir.call @_FortranADestroy(%[[VAL_10]]) fastmath<contract> : (!fir.box<none>) -> none
+subroutine test4b
+ class(*), allocatable :: p(:, :)
+ p = inner()
+contains
+ function inner()
+ class(*), allocatable :: inner(:, :)
+ end function inner
+end subroutine test4b
+! CHECK-LABEL: func.func @_QPtest4b() {
+! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0:.*]] : !fir.ref<!fir.class<!fir.heap<!fir.array<?x?xnone>>>>
+! CHECK: %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_6]] {uniq_name = ".tmp.func_result"} : (!fir.class<!fir.heap<!fir.array<?x?xnone>>>) -> (!fir.class<!fir.heap<!fir.array<?x?xnone>>>, !fir.class<!fir.heap<!fir.array<?x?xnone>>>)
+! CHECK: hlfir.assign %[[VAL_7]]#0 to %{{.*}}#0 realloc : !fir.class<!fir.heap<!fir.array<?x?xnone>>>, !fir.ref<!fir.class<!fir.heap<!fir.array<?x?xnone>>>>
+! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.class<!fir.heap<!fir.array<?x?xnone>>>>) -> !fir.box<none>
+! CHECK: fir.call @_FortranADestroy(%[[VAL_10]]) fastmath<contract> : (!fir.box<none>) -> none
+
subroutine test5
use types
type(t1) :: r
More information about the flang-commits
mailing list