Skip to content

Commit 356bf3f

Browse files
jeanPerierNimishMishra
jeanPerier
and
NimishMishra
authored
Reland " [flang] Rely on global initialization for simpler derived types" (#130290)
Currently, all derived types are initialized through `_FortranAInitialize`, which is functionally correct, but bears poor runtime performance. This patch falls back on global initialization for "simpler" derived types to speed up the initialization. Note: this relands #114002 with the fix for the LLVM timeout regressions that have been seen. The fix is to use the added fir.copy to avoid aggregate load/store. Co-authored-by: NimishMishra <42909663+NimishMishra@users.noreply.github.com>
1 parent 5038e2f commit 356bf3f

9 files changed

+113
-91
lines changed

‎flang/include/flang/Optimizer/Support/InternalNames.h

+1
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@ static constexpr llvm::StringRef kProcPtrSeparator = ".p.";
3030
static constexpr llvm::StringRef kSpecialBindingSeparator = ".s.";
3131
static constexpr llvm::StringRef kBindingTableSeparator = ".v.";
3232
static constexpr llvm::StringRef boxprocSuffix = "UnboxProc";
33+
static constexpr llvm::StringRef kDerivedTypeInitSuffix = "DerivedInit";
3334

3435
/// Internal name mangling of identifiers
3536
///

‎flang/lib/Lower/ConvertVariable.cpp

+60-2
Original file line numberDiff line numberDiff line change
@@ -798,8 +798,66 @@ void Fortran::lower::defaultInitializeAtRuntime(
798798
})
799799
.end();
800800
} else {
801-
mlir::Value box = builder.createBox(loc, exv);
802-
fir::runtime::genDerivedTypeInitialize(builder, loc, box);
801+
/// For "simpler" types, relying on "_FortranAInitialize"
802+
/// leads to poor runtime performance. Hence optimize
803+
/// the same.
804+
const Fortran::semantics::DeclTypeSpec *declTy = sym.GetType();
805+
mlir::Type symTy = converter.genType(sym);
806+
const auto *details =
807+
sym.detailsIf<Fortran::semantics::ObjectEntityDetails>();
808+
if (details && !Fortran::semantics::IsPolymorphic(sym) &&
809+
declTy->category() ==
810+
Fortran::semantics::DeclTypeSpec::Category::TypeDerived &&
811+
!mlir::isa<fir::SequenceType>(symTy) &&
812+
!sym.test(Fortran::semantics::Symbol::Flag::OmpPrivate) &&
813+
!sym.test(Fortran::semantics::Symbol::Flag::OmpFirstPrivate)) {
814+
std::string globalName = fir::NameUniquer::doGenerated(
815+
(converter.mangleName(*declTy->AsDerived()) + fir::kNameSeparator +
816+
fir::kDerivedTypeInitSuffix)
817+
.str());
818+
mlir::Location loc = genLocation(converter, sym);
819+
mlir::StringAttr linkage = builder.createInternalLinkage();
820+
fir::GlobalOp global = builder.getNamedGlobal(globalName);
821+
if (!global && details->init()) {
822+
global = builder.createGlobal(loc, symTy, globalName, linkage,
823+
mlir::Attribute{},
824+
/*isConst=*/true,
825+
/*isTarget=*/false,
826+
/*dataAttr=*/{});
827+
Fortran::lower::createGlobalInitialization(
828+
builder, global, [&](fir::FirOpBuilder &builder) {
829+
Fortran::lower::StatementContext stmtCtx(
830+
/*cleanupProhibited=*/true);
831+
fir::ExtendedValue initVal = genInitializerExprValue(
832+
converter, loc, details->init().value(), stmtCtx);
833+
mlir::Value castTo =
834+
builder.createConvert(loc, symTy, fir::getBase(initVal));
835+
builder.create<fir::HasValueOp>(loc, castTo);
836+
});
837+
} else if (!global) {
838+
global = builder.createGlobal(loc, symTy, globalName, linkage,
839+
mlir::Attribute{},
840+
/*isConst=*/true,
841+
/*isTarget=*/false,
842+
/*dataAttr=*/{});
843+
Fortran::lower::createGlobalInitialization(
844+
builder, global, [&](fir::FirOpBuilder &builder) {
845+
Fortran::lower::StatementContext stmtCtx(
846+
/*cleanupProhibited=*/true);
847+
mlir::Value initVal = genDefaultInitializerValue(
848+
converter, loc, sym, symTy, stmtCtx);
849+
mlir::Value castTo = builder.createConvert(loc, symTy, initVal);
850+
builder.create<fir::HasValueOp>(loc, castTo);
851+
});
852+
}
853+
auto addrOf = builder.create<fir::AddrOfOp>(loc, global.resultType(),
854+
global.getSymbol());
855+
builder.create<fir::CopyOp>(loc, addrOf, fir::getBase(exv),
856+
/*noOverlap=*/true);
857+
} else {
858+
mlir::Value box = builder.createBox(loc, exv);
859+
fir::runtime::genDerivedTypeInitialize(builder, loc, box);
860+
}
803861
}
804862
}
805863

‎flang/test/Lower/HLFIR/structure-constructor.f90

+14-42
Large diffs are not rendered by default.

‎flang/test/Lower/OpenMP/private-derived-type.f90

+5-9
Original file line numberDiff line numberDiff line change
@@ -27,18 +27,14 @@ end subroutine s4
2727

2828
! CHECK-LABEL: func.func @_QPs4() {
2929
! Example of how the lowering for regular derived type variables:
30-
! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}> {bindc_name = "v", uniq_name = "_QFs4Ev"}
31-
! CHECK: %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_8]] {uniq_name = "_QFs4Ev"} : (!fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> (!fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>, !fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>)
32-
! CHECK: %[[VAL_10:.*]] = fir.embox %[[VAL_9]]#1 : (!fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>
33-
! CHECK: %[[VAL_11:.*]] = fir.address_of
34-
! CHECK: %[[VAL_12:.*]] = arith.constant 4 : i32
35-
! CHECK: %[[VAL_13:.*]] = fir.convert %[[VAL_10]] : (!fir.box<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<none>
36-
! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_11]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
37-
! CHECK: fir.call @_FortranAInitialize(%[[VAL_13]], %[[VAL_14]], %[[VAL_12]]) fastmath<contract> : (!fir.box<none>, !fir.ref<i8>, i32) -> ()
30+
! CHECK: %[[VAL_DERIVED_ALLOCA:.*]] = fir.alloca !fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}> {bindc_name = "v", uniq_name = "_QFs4Ev"}
31+
! CHECK: %[[VAL_DERIVED_DECLARE:.*]]:2 = hlfir.declare %[[VAL_DERIVED_ALLOCA]] {{.*}}
32+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QFs4Ty3.DerivedInit) : !fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>
33+
! CHECK: fir.copy %[[ADDR]] to %[[VAL_DERIVED_DECLARE]]#1 no_overlap : {{.*}}
3834
! CHECK: omp.parallel {
3935
! CHECK: omp.wsloop private(@[[DERIVED_PRIV]] %{{.*}}#0 -> %{{.*}}, @{{.*}} %{{.*}}#0 -> %{{.*}} : !fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>, !fir.ref<i32>) {
4036
! CHECK: }
41-
! CHECK: %[[VAL_39:.*]] = fir.embox %[[VAL_9]]#1 : (!fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>
37+
! CHECK: %[[VAL_39:.*]] = fir.embox %[[VAL_DERIVED_DECLARE]]#1 : (!fir.ref<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>
4238
! CHECK: %[[VAL_40:.*]] = fir.convert %[[VAL_39]] : (!fir.box<!fir.type<_QFs4Ty3{x:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<none>
4339
! Check the derived type is destroyed
4440
! CHECK: fir.call @_FortranADestroy(%[[VAL_40]]) fastmath<contract> : (!fir.box<none>) -> ()

‎flang/test/Lower/default-initialization.f90

+17-24
Original file line numberDiff line numberDiff line change
@@ -21,10 +21,9 @@ module test_dinit
2121
! Test local scalar is default initialized
2222
! CHECK-LABEL: func @_QMtest_dinitPlocal()
2323
subroutine local
24-
! CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt{i:i32}>
25-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTt{i:i32}>>
26-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
27-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
24+
!CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt{i:i32}> {bindc_name = "x", uniq_name = "_QMtest_dinitFlocalEx"}
25+
!CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTt.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
26+
!CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>, !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
2827
type(t) :: x
2928
print *, x%i
3029
end subroutine
@@ -45,30 +44,27 @@ subroutine local_array()
4544
! scalars.
4645
! CHECK-LABEL: func @_QMtest_dinitPlocal_alloc_comp()
4746
subroutine local_alloc_comp
48-
! CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>
49-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>) -> !fir.box<!fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
50-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
51-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
47+
!CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}> {bindc_name = "x", uniq_name = "_QMtest_dinitFlocal_alloc_compEx"}
48+
!CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTt_alloc_comp.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
49+
!CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>, !fir.ref<!fir.type<_QMtest_dinitTt_alloc_comp{i:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
5250
type(t_alloc_comp) :: x
5351
end subroutine
5452

5553
! Test function results are default initialized.
5654
! CHECK-LABEL: func @_QMtest_dinitPresult() -> !fir.type<_QMtest_dinitTt{i:i32}>
5755
function result()
58-
! CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt{i:i32}>
59-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTt{i:i32}>>
60-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
61-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
56+
!CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtest_dinitTt{i:i32}> {bindc_name = "result", uniq_name = "_QMtest_dinitFresultEresult"}
57+
!CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTt.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
58+
!CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>, !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
6259
type(t) :: result
6360
end function
6461

6562
! Test intent(out) dummies are default initialized
6663
! CHECK-LABEL: func @_QMtest_dinitPintent_out(
6764
! CHECK-SAME: %[[x:.*]]: !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
6865
subroutine intent_out(x)
69-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTt{i:i32}>>
70-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
71-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
66+
!CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTt.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
67+
!CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>, !fir.ref<!fir.type<_QMtest_dinitTt{i:i32}>>
7268
type(t), intent(out) :: x
7369
end subroutine
7470

@@ -94,9 +90,8 @@ subroutine local_eq()
9490
! CHECK: %[[equiv:.*]] = fir.alloca !fir.array<4xi8>
9591
! CHECK: %[[xcoor:.*]] = fir.coordinate_of %[[equiv]], %c0{{.*}} : (!fir.ref<!fir.array<4xi8>>, index) -> !fir.ref<i8>
9692
! CHECK: %[[x:.*]] = fir.convert %[[xcoor]] : (!fir.ref<i8>) -> !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
97-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
98-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
99-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
93+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTtseq.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>
94+
! CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>, !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
10095
equivalence (x, zi)
10196
print *, i
10297
end subroutine
@@ -112,16 +107,14 @@ subroutine local_eq2()
112107
! CHECK: %[[equiv:.*]] = fir.alloca !fir.array<4xi8>
113108
! CHECK: %[[xcoor:.*]] = fir.coordinate_of %[[equiv]], %c0{{.*}} : (!fir.ref<!fir.array<4xi8>>, index) -> !fir.ref<i8>
114109
! CHECK: %[[x:.*]] = fir.convert %[[xcoor]] : (!fir.ref<i8>) -> !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
115-
! CHECK: %[[xbox:.*]] = fir.embox %[[x]] : (!fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
116-
! CHECK: %[[xboxNone:.*]] = fir.convert %[[xbox]]
117-
! CHECK: fir.call @_FortranAInitialize(%[[xboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
110+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTtseq.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>
111+
! CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>, !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
118112

119113

120114
! CHECK: %[[ycoor:.*]] = fir.coordinate_of %[[equiv]], %c0{{.*}} : (!fir.ref<!fir.array<4xi8>>, index) -> !fir.ref<i8>
121115
! CHECK: %[[y:.*]] = fir.convert %[[ycoor]] : (!fir.ref<i8>) -> !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
122-
! CHECK: %[[ybox:.*]] = fir.embox %[[y]] : (!fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>) -> !fir.box<!fir.type<_QMtest_dinitTtseq{i:i32}>>
123-
! CHECK: %[[yboxNone:.*]] = fir.convert %[[ybox]]
124-
! CHECK: fir.call @_FortranAInitialize(%[[yboxNone]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
116+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtest_dinitTtseq.DerivedInit) : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>
117+
! CHECK: fir.copy %[[ADDR]] to %[[y]] no_overlap : !fir.ref<!fir.type<_QMtest_dinitTtseq{i:i32}>>, !fir.ptr<!fir.type<_QMtest_dinitTtseq{i:i32}>>
125118
equivalence (x, y)
126119
print *, y%i
127120
end subroutine

‎flang/test/Lower/derived-type-finalization.f90

+6-2
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,9 @@ subroutine test_target_finalization()
9797

9898
! CHECK-LABEL: func.func @_QMderived_type_finalizationPtest_target_finalization() {
9999
! CHECK: %[[P:.*]] = fir.alloca !fir.box<!fir.ptr<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>> {bindc_name = "p", uniq_name = "_QMderived_type_finalizationFtest_target_finalizationEp"}
100-
! CHECK: fir.call @_FortranAInitialize
100+
! CHECK: %[[ADDR:.*]] = fir.alloca !fir.ptr<!fir.type<_QMderived_type_finalizationTt1{a:i32}>> {uniq_name = "_QMderived_type_finalizationFtest_target_finalizationEp.addr"}
101+
! CHECK: %[[zero:.*]] = fir.zero_bits !fir.ptr<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>
102+
! CHECK: fir.store %[[zero]] to %[[ADDR]] : !fir.ref<!fir.ptr<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>>
101103
! CHECK: fir.call @_FortranAPointerAllocateSource
102104
! CHECK: %[[P_BOX_NONE:.*]] = fir.convert %[[P]] : (!fir.ref<!fir.box<!fir.ptr<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>>>) -> !fir.ref<!fir.box<none>>
103105
! CHECK: %{{.*}} = fir.call @_FortranAPointerDeallocate(%[[P_BOX_NONE]], %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {{.*}} : (!fir.ref<!fir.box<none>>, i1, !fir.box<none>, !fir.ref<i8>, i32) -> i32
@@ -199,7 +201,9 @@ subroutine test_avoid_double_finalization(a)
199201
end subroutine
200202

201203
! CHECK-LABEL: func.func @_QMderived_type_finalizationPtest_avoid_double_finalization(
202-
! CHECK: fir.call @_FortranAInitialize(
204+
! CHECK: %[[b:.*]] = fir.alloca !fir.type<_QMderived_type_finalizationTt3{t:!fir.type<_QMderived_type_finalizationTt2{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>}> {bindc_name = "b", uniq_name = "_QMderived_type_finalizationFtest_avoid_double_finalizationEb"}
205+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMderived_type_finalizationTt3.DerivedInit) : !fir.ref<!fir.type<_QMderived_type_finalizationTt3{t:!fir.type<_QMderived_type_finalizationTt2{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>}>>
206+
! CHECK: fir.copy %[[ADDR]] to %[[b]] no_overlap : !fir.ref<!fir.type<_QMderived_type_finalizationTt3{t:!fir.type<_QMderived_type_finalizationTt2{a:!fir.box<!fir.heap<!fir.array<?xi32>>>}>}>>
203207
! CHECK-NOT: fir.call @_FortranADestroy
204208
! CHECK: fir.call @_FortranAAssign(
205209
! CHECK: fir.call @_FortranADestroy(

‎flang/test/Lower/derived-type-temp.f90

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
! Test lowering of derived type temporary creation and init
2-
! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
2+
! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
33

44
program derived_temp_init
55
type t1
@@ -13,7 +13,7 @@ program derived_temp_init
1313
y = t2(x)
1414
end
1515

16-
! CHECK: %[[temp:.*]] = fir.alloca !fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}> {bindc_name = "x", uniq_name = "_QFEx"}
17-
! CHECK: %[[box:.*]] = fir.embox %[[temp]] : (!fir.ref<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>
18-
! CHECK: %[[box_none:.*]] = fir.convert %[[box]] : (!fir.box<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>) -> !fir.box<none>
19-
! CHECK: fir.call @_FortranAInitialize(%[[box_none]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
16+
! CHECK: %[[ALLOC:.*]] = fir.alloca !fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}> {bindc_name = "x", uniq_name = "_QFEx"}
17+
! CHECK: %[[x:.*]]:2 = hlfir.declare %[[ALLOC]] {{.*}}
18+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QFTt1.DerivedInit) : !fir.ref<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>
19+
! CHECK: fir.copy %[[ADDR]] to %[[x]]#1 no_overlap : !fir.ref<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>, !fir.ref<!fir.type<_QFTt1{i:!fir.box<!fir.heap<i32>>}>>

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

+2-6
Original file line numberDiff line numberDiff line change
@@ -18,12 +18,8 @@ end subroutine forall_with_allocatable2
1818
! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
1919
! CHECK: %[[VAL_1:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
2020
! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}> {bindc_name = "thing", uniq_name = "_QFforall_with_allocatable2Ething"}
21-
! CHECK: %[[VAL_3:.*]] = fir.embox %[[VAL_2]] : (!fir.ref<!fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>) -> !fir.box<!fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
22-
! CHECK: %[[VAL_4:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
23-
! CHECK: %[[VAL_5:.*]] = arith.constant {{.*}} : i32
24-
! CHECK: %[[VAL_6:.*]] = fir.convert %[[VAL_3]] : (!fir.box<!fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>) -> !fir.box<none>
25-
! CHECK: %[[VAL_7:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
26-
! CHECK: fir.call @_FortranAInitialize(%[[VAL_6]], %[[VAL_7]], %[[VAL_5]]) {{.*}}: (!fir.box<none>, !fir.ref<i8>, i32) -> ()
21+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QFforall_with_allocatable2Tt.DerivedInit) : !fir.ref<!fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
22+
! CHECK: fir.copy %[[ADDR]] to %[[VAL_2]] no_overlap : !fir.ref<!fir.type<_QFforall_with_allocatable2Tt{i:i32,arr:!fir.box<!fir.heap<!fir.array<?xf32>>>}>>
2723
! CHECK: %[[VAL_9:.*]] = arith.constant 5 : i32
2824
! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i32) -> index
2925
! CHECK: %[[VAL_11:.*]] = arith.constant 15 : i32

‎flang/test/Lower/pointer-default-init.f90

+3-1
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,9 @@ subroutine test_local()
3838
type(t) :: x
3939
end subroutine
4040
! CHECK-LABEL: func.func @_QPtest_local() {
41-
! CHECK: fir.call @_FortranAInitialize(
41+
! CHECK: %[[x:.*]] = fir.alloca !fir.type<_QMtestTt{i:i32,x:!fir.box<!fir.ptr<!fir.array<?xf32>>>}> {bindc_name = "x", uniq_name = "_QFtest_localEx"}
42+
! CHECK: %[[ADDR:.*]] = fir.address_of(@_QQ_QMtestTt.DerivedInit) : !fir.ref<!fir.type<_QMtestTt{i:i32,x:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
43+
! CHECK: fir.copy %[[ADDR]] to %[[x]] no_overlap : !fir.ref<!fir.type<_QMtestTt{i:i32,x:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>, !fir.ref<!fir.type<_QMtestTt{i:i32,x:!fir.box<!fir.ptr<!fir.array<?xf32>>>}>>
4244

4345
subroutine test_saved()
4446
use test, only : t

0 commit comments

Comments
 (0)