[flang-commits] [flang] [flang][NFC] Finishing touches on legacy lowering conversion (PR #197973)
via flang-commits
flang-commits at lists.llvm.org
Fri May 15 09:46:35 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: Eugene Epshteyn (eugeneepshteyn)
<details>
<summary>Changes</summary>
At the beginning of legacy lowering conversion, some tests were initially converted to emit FIR. After some discussion, it was decided to revisit those tests and convert them to emit HLFIR. This change completes that step and should be the final change in removing vestiges of legacy lowering.
---
Patch is 72.78 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/197973.diff
11 Files Affected:
- (modified) flang/test/Lower/achar.f90 (+21-14)
- (modified) flang/test/Lower/allocatable-return.f90 (+30-28)
- (modified) flang/test/Lower/allocatable-runtime.f90 (+50-52)
- (modified) flang/test/Lower/allocate-mold.f90 (+8-9)
- (modified) flang/test/Lower/allocate-source-allocatables.f90 (+47-47)
- (modified) flang/test/Lower/allocated.f90 (+6-6)
- (modified) flang/test/Lower/always-execute-loop-body.f90 (+8-6)
- (modified) flang/test/Lower/arithmetic-goto.f90 (+27-26)
- (modified) flang/test/Lower/array-constructor-1.f90 (+8-7)
- (modified) flang/test/Lower/array-constructor-index.f90 (+42-56)
- (modified) flang/test/Lower/array-derived.f90 (+45-69)
``````````diff
diff --git a/flang/test/Lower/achar.f90 b/flang/test/Lower/achar.f90
index f5b3168c424ca..4ab6066adfae4 100644
--- a/flang/test/Lower/achar.f90
+++ b/flang/test/Lower/achar.f90
@@ -1,4 +1,4 @@
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! Tests ACHAR lowering (converting an INTEGER to a CHARACTER (singleton, LEN=1)
! along with conversion of CHARACTER to another KIND.
@@ -11,17 +11,24 @@ subroutine achar_test1(a)
call achar_test1_foo(ch)
end subroutine achar_test1
-! CHECK-LABEL: func @_QPachar_test1(
-! CHECK-SAME: %[[arg:.*]]: !fir.ref<i32> {fir.bindc_name = "a"}) {
-! CHECK: %[[VAL_TMP_ALLOCA:.*]] = fir.alloca !fir.char<2> {bindc_name = ".tmp"}
-! CHECK: %[[VAL_1_ALLOCA:.*]] = fir.alloca !fir.char<1>
-! CHECK: %[[VAL_DUMMY_SCOPE:.*]] = fir.dummy_scope : !fir.dscope
-! CHECK: %[[VAL_DECLARE:.*]] = fir.declare %[[arg]] dummy_scope %[[VAL_DUMMY_SCOPE]] arg 1 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFachar_test1Ea"} : (!fir.ref<i32>, !fir.dscope) -> !fir.ref<i32>
-! CHECK: %[[VAL_CH_ALLOCA:.*]] = fir.alloca !fir.char<2> {bindc_name = "ch", uniq_name = "_QFachar_test1Ech"}
-! CHECK: %[[VAL_2:.*]] = fir.load %[[VAL_DECLARE]] : !fir.ref<i32>
-! CHECK: %[[VAL_5:.*]] = fir.undefined !fir.char<1>
-! CHECK: %[[VAL_6:.*]] = fir.insert_value %[[VAL_5]], %{{.*}}, [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
-! CHECK: fir.store %[[VAL_6]] to %[[VAL_1_ALLOCA]] : !fir.ref<!fir.char<1>>
-! CHECK: %[[VAL_7:.*]] = fir.alloca !fir.char<2,?>(%{{.*}} : index)
-! CHECK: fir.char_convert %[[VAL_1_ALLOCA]] for %{{.*}} to %[[VAL_7]] : !fir.ref<!fir.char<1>>, index, !fir.ref<!fir.char<2,?>>
+! CHECK-LABEL: func.func @_QPachar_test1(
+! CHECK-SAME: %[[ARG:.*]]: !fir.ref<i32> {fir.bindc_name = "a"}) {
+! CHECK: %[[TMP:.*]] = fir.alloca !fir.char<1>
+! CHECK: %[[DSCOPE:.*]] = fir.dummy_scope : !fir.dscope
+! CHECK: %[[A:.*]]:2 = hlfir.declare %[[ARG]] dummy_scope %[[DSCOPE]] arg 1 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFachar_test1Ea"}
+! CHECK: %[[CH_ALLOCA:.*]] = fir.alloca !fir.char<2> {bindc_name = "ch", uniq_name = "_QFachar_test1Ech"}
+! CHECK: %[[CH:.*]]:2 = hlfir.declare %[[CH_ALLOCA]] typeparams %{{.*}} {uniq_name = "_QFachar_test1Ech"}
+! CHECK: %[[A_VAL:.*]] = fir.load %[[A]]#0 : !fir.ref<i32>
+! CHECK: %[[A_I64:.*]] = fir.convert %[[A_VAL]] : (i32) -> i64
+! CHECK: %[[A_I8:.*]] = fir.convert %[[A_I64]] : (i64) -> i8
+! CHECK: %[[CHAR:.*]] = fir.insert_value %{{.*}}, %[[A_I8]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
+! CHECK: fir.store %[[CHAR]] to %[[TMP]] : !fir.ref<!fir.char<1>>
+! CHECK: %[[EXPR:.*]] = hlfir.as_expr %[[TMP]]
+! CHECK: %[[ASSOC:.*]]:3 = hlfir.associate %[[EXPR]]
+! CHECK: %[[KIND_TMP:.*]] = fir.alloca !fir.char<2,?>(%{{.*}} : index)
+! CHECK: fir.char_convert %[[ASSOC]]#0 for %{{.*}} to %[[KIND_TMP]] : !fir.ref<!fir.char<1>>, index, !fir.ref<!fir.char<2,?>>
+! CHECK: %[[CONVERTED:.*]]:2 = hlfir.declare %[[KIND_TMP]] typeparams %{{.*}} {uniq_name = ".temp.kindconvert"}
+! CHECK: %[[SET_LENGTH:.*]] = hlfir.set_length %[[CONVERTED]]#0
+! CHECK: hlfir.assign %[[SET_LENGTH]] to %[[CH]]#0
+! CHECK: hlfir.destroy %[[EXPR]]
! CHECK: fir.call @_QPachar_test1_foo(%{{.*}}) {{.*}}: (!fir.boxchar<2>) -> ()
diff --git a/flang/test/Lower/allocatable-return.f90 b/flang/test/Lower/allocatable-return.f90
index 1cc1ebece719c..f00b31a03f54d 100644
--- a/flang/test/Lower/allocatable-return.f90
+++ b/flang/test/Lower/allocatable-return.f90
@@ -1,4 +1,4 @@
-! RUN: %flang_fc1 -emit-fir -I nowhere %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -I nowhere %s -o - | FileCheck %s
! Test allocatable return.
! Allocatable arrays must have default runtime lbounds after the return.
@@ -9,9 +9,9 @@ function test_alloc_return_scalar
end function test_alloc_return_scalar
! CHECK-LABEL: func.func @_QPtest_alloc_return_scalar() -> !fir.box<!fir.heap<f32>> {
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<f32>> {bindc_name = "test_alloc_return_scalar", uniq_name = "_QFtest_alloc_return_scalarEtest_alloc_return_scalar"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.box<!fir.heap<f32>>>
-! CHECK: return %[[VAL_5]] : !fir.box<!fir.heap<f32>>
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<f32>>>
+! CHECK: return %[[VAL]] : !fir.box<!fir.heap<f32>>
! CHECK: }
function test_alloc_return_array
@@ -19,13 +19,13 @@ function test_alloc_return_array
allocate(test_alloc_return_array(7:8))
end function test_alloc_return_array
! CHECK-LABEL: func.func @_QPtest_alloc_return_array() -> !fir.box<!fir.heap<!fir.array<?xf32>>> {
-! CHECK: %[[C1:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {bindc_name = "test_alloc_return_array", uniq_name = "_QFtest_alloc_return_arrayEtest_alloc_return_array"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
-! CHECK: %[[VAL_20:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
-! CHECK: %[[VAL_21:.*]] = fir.rebox %[[VAL_18]](%[[VAL_20]]) : (!fir.box<!fir.heap<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
-! CHECK: return %[[VAL_21]] : !fir.box<!fir.heap<!fir.array<?xf32>>>
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
+! CHECK: %[[C1:.*]] = arith.constant 1 : index
+! CHECK: %[[SHIFT:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
+! CHECK: %[[REBOX:.*]] = fir.rebox %[[VAL]](%[[SHIFT]]) : (!fir.box<!fir.heap<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
+! CHECK: return %[[REBOX]] : !fir.box<!fir.heap<!fir.array<?xf32>>>
! CHECK: }
function test_alloc_return_char_scalar
@@ -34,9 +34,10 @@ function test_alloc_return_char_scalar
end function test_alloc_return_char_scalar
! CHECK-LABEL: func.func @_QPtest_alloc_return_char_scalar() -> !fir.box<!fir.heap<!fir.char<1,3>>> {
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.char<1,3>>> {bindc_name = "test_alloc_return_char_scalar", uniq_name = "_QFtest_alloc_return_char_scalarEtest_alloc_return_char_scalar"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.box<!fir.heap<!fir.char<1,3>>>>
-! CHECK: return %[[VAL_5]] : !fir.box<!fir.heap<!fir.char<1,3>>>
+! CHECK: %[[LEN:.*]] = arith.constant 3 : index
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[LEN]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.char<1,3>>>>
+! CHECK: return %[[VAL]] : !fir.box<!fir.heap<!fir.char<1,3>>>
! CHECK: }
function test_alloc_return_char_array
@@ -44,13 +45,14 @@ function test_alloc_return_char_array
allocate(test_alloc_return_char_array(7:8))
end function test_alloc_return_char_array
! CHECK-LABEL: func.func @_QPtest_alloc_return_char_array() -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>> {
-! CHECK: %[[C1:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>> {bindc_name = "test_alloc_return_char_array", uniq_name = "_QFtest_alloc_return_char_arrayEtest_alloc_return_char_array"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_18:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>>
-! CHECK: %[[VAL_20:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
-! CHECK: %[[VAL_21:.*]] = fir.rebox %[[VAL_18]](%[[VAL_20]]) : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>, !fir.shift<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>
-! CHECK: return %[[VAL_21]] : !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>
+! CHECK: %[[LEN:.*]] = arith.constant 3 : index
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] typeparams %[[LEN]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>>
+! CHECK: %[[C1:.*]] = arith.constant 1 : index
+! CHECK: %[[SHIFT:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
+! CHECK: %[[REBOX:.*]] = fir.rebox %[[VAL]](%[[SHIFT]]) : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>, !fir.shift<1>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>
+! CHECK: return %[[REBOX]] : !fir.box<!fir.heap<!fir.array<?x!fir.char<1,3>>>>
! CHECK: }
function test_alloc_return_poly_scalar
@@ -61,9 +63,9 @@ function test_alloc_return_poly_scalar
end function test_alloc_return_poly_scalar
! CHECK-LABEL: func.func @_QPtest_alloc_return_poly_scalar() -> !fir.class<!fir.heap<none>> {
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.class<!fir.heap<none>> {bindc_name = "test_alloc_return_poly_scalar", uniq_name = "_QFtest_alloc_return_poly_scalarEtest_alloc_return_poly_scalar"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_16:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.class<!fir.heap<none>>>
-! CHECK: return %[[VAL_16]] : !fir.class<!fir.heap<none>>
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.class<!fir.heap<none>>>
+! CHECK: return %[[VAL]] : !fir.class<!fir.heap<none>>
! CHECK: }
function test_alloc_return_poly_array
@@ -73,11 +75,11 @@ function test_alloc_return_poly_array
allocate(t :: test_alloc_return_poly_array(7:8))
end function test_alloc_return_poly_array
! CHECK-LABEL: func.func @_QPtest_alloc_return_poly_array() -> !fir.class<!fir.heap<!fir.array<?xnone>>> {
-! CHECK: %[[C1:.*]] = arith.constant 1 : index
! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.class<!fir.heap<!fir.array<?xnone>>> {bindc_name = "test_alloc_return_poly_array", uniq_name = "_QFtest_alloc_return_poly_arrayEtest_alloc_return_poly_array"}
-! CHECK: %[[VAL_DECL:.*]] = fir.declare %[[VAL_0]] {{.*}}
-! CHECK: %[[VAL_25:.*]] = fir.load %[[VAL_DECL]] : !fir.ref<!fir.class<!fir.heap<!fir.array<?xnone>>>>
-! CHECK: %[[VAL_27:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
-! CHECK: %[[VAL_28:.*]] = fir.rebox %[[VAL_25]](%[[VAL_27]]) : (!fir.class<!fir.heap<!fir.array<?xnone>>>, !fir.shift<1>) -> !fir.class<!fir.heap<!fir.array<?xnone>>>
-! CHECK: return %[[VAL_28]] : !fir.class<!fir.heap<!fir.array<?xnone>>>
+! CHECK: %[[VAL_DECL:.*]]:2 = hlfir.declare %[[VAL_0]] {{.*}}
+! CHECK: %[[VAL:.*]] = fir.load %[[VAL_DECL]]#0 : !fir.ref<!fir.class<!fir.heap<!fir.array<?xnone>>>>
+! CHECK: %[[C1:.*]] = arith.constant 1 : index
+! CHECK: %[[SHIFT:.*]] = fir.shift %[[C1]] : (index) -> !fir.shift<1>
+! CHECK: %[[REBOX:.*]] = fir.rebox %[[VAL]](%[[SHIFT]]) : (!fir.class<!fir.heap<!fir.array<?xnone>>>, !fir.shift<1>) -> !fir.class<!fir.heap<!fir.array<?xnone>>>
+! CHECK: return %[[REBOX]] : !fir.class<!fir.heap<!fir.array<?xnone>>>
! CHECK: }
diff --git a/flang/test/Lower/allocatable-runtime.f90 b/flang/test/Lower/allocatable-runtime.f90
index 2fb54fb969127..5d9528a9779d5 100644
--- a/flang/test/Lower/allocatable-runtime.f90
+++ b/flang/test/Lower/allocatable-runtime.f90
@@ -1,102 +1,100 @@
-! RUN: %flang_fc1 -emit-fir -O2 -mllvm -use-alloc-runtime %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -O2 -mllvm -use-alloc-runtime %s -o - | FileCheck %s
! Test lowering of allocatables using runtime for allocate/deallcoate statements.
-! CHECK-LABEL: _QPfoo
+! CHECK-LABEL: func.func @_QPfoo
subroutine foo()
real, allocatable :: x(:), y(:, :), z
- ! CHECK-DAG: %[[xlb:.*]] = arith.constant 42 : i32
- ! CHECK-DAG: %[[xub:.*]] = arith.constant 100 : i32
! CHECK-DAG: %[[xBoxAddr:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xf32>>> {{{.*}}uniq_name = "_QFfooEx"}
! CHECK-DAG: %[[xNullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?xf32>>
- ! CHECK-DAG: %[[xInitEmbox:.*]] = fir.embox %[[xNullAddr]]
+ ! CHECK-DAG: %[[xInitEmbox:.*]] = fir.embox %[[xNullAddr]]{{.*}}
! CHECK-DAG: fir.store %[[xInitEmbox]] to %[[xBoxAddr]]
- ! CHECK-DAG: %[[xBoxDecl:.*]] = fir.declare %[[xBoxAddr]]{{.*}}
+ ! CHECK-DAG: %[[xBoxDecl:.*]]:2 = hlfir.declare %[[xBoxAddr]]{{.*}}
! CHECK-DAG: %[[yBoxAddr:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xf32>>> {{{.*}}uniq_name = "_QFfooEy"}
! CHECK-DAG: %[[yNullAddr:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xf32>>
- ! CHECK-DAG: %[[yInitEmbox:.*]] = fir.embox %[[yNullAddr]]
+ ! CHECK-DAG: %[[yInitEmbox:.*]] = fir.embox %[[yNullAddr]]{{.*}}
! CHECK-DAG: fir.store %[[yInitEmbox]] to %[[yBoxAddr]]
- ! CHECK-DAG: %[[yBoxDecl:.*]] = fir.declare %[[yBoxAddr]]{{.*}}
+ ! CHECK-DAG: %[[yBoxDecl:.*]]:2 = hlfir.declare %[[yBoxAddr]]{{.*}}
! CHECK-DAG: %[[zBoxAddr:.*]] = fir.alloca !fir.box<!fir.heap<f32>> {{{.*}}uniq_name = "_QFfooEz"}
! CHECK-DAG: %[[zNullAddr:.*]] = fir.zero_bits !fir.heap<f32>
! CHECK-DAG: %[[zInitEmbox:.*]] = fir.embox %[[zNullAddr]]
! CHECK-DAG: fir.store %[[zInitEmbox]] to %[[zBoxAddr]]
- ! CHECK-DAG: %[[zBoxDecl:.*]] = fir.declare %[[zBoxAddr]]{{.*}}
+ ! CHECK-DAG: %[[zBoxDecl:.*]]:2 = hlfir.declare %[[zBoxAddr]]{{.*}}
allocate(x(42:100), y(43:50, 51), z)
! CHECK-DAG: %[[errMsg:.*]] = fir.absent !fir.box<none>
- ! CHECK-DAG: %[[xBoxCast2:.*]] = fir.convert %[[xBoxDecl]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[xlb:.*]] = arith.constant 42 : i32
+ ! CHECK-DAG: %[[xub:.*]] = arith.constant 100 : i32
+ ! CHECK-DAG: %[[xBoxCast2:.*]] = fir.convert %[[xBoxDecl]]#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> !fir.ref<!fir.box<none>>
! CHECK-DAG: %[[xlbCast:.*]] = fir.convert %[[xlb]] : (i32) -> i64
! CHECK-DAG: %[[xubCast:.*]] = fir.convert %[[xub]] : (i32) -> i64
! CHECK: fir.call @{{.*}}AllocatableSetBounds(%[[xBoxCast2]], %c0{{.*}}, %[[xlbCast]], %[[xubCast]]) {{.*}}: (!fir.ref<!fir.box<none>>, i32, i64, i64) -> ()
- ! CHECK: fir.call @{{.*}}AllocatableAllocate(%[[xBoxCast2]], %{{.*}}, %false{{.*}}, %[[errMsg]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.ref<i64>, i1, !fir.box<none>, !fir.ref<i8>, i32, {{.*}}) -> i32
+ ! CHECK: fir.call @{{.*}}AllocatableAllocate(%{{.*}}, %{{.*}}, %false{{.*}}, %[[errMsg]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.ref<i64>, i1, !fir.box<none>, !fir.ref<i8>, i32, {{.*}}) -> i32
! Simply check that we are emitting the right numebr of set bound for y and z. Otherwise, this is just like x.
- ! CHECK: %[[yBoxCast:.*]] = fir.convert %[[yBoxDecl]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK: %[[yBoxCast:.*]] = fir.convert %[[yBoxDecl]]#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>) -> !fir.ref<!fir.box<none>>
! CHECK: fir.call @{{.*}}AllocatableSetBounds
! CHECK: fir.call @{{.*}}AllocatableSetBounds
! CHECK: fir.call @{{.*}}AllocatableAllocate
- ! CHECK: %[[zBoxCast:.*]] = fir.convert %[[zBoxDecl]] : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK: %[[zBoxCast:.*]] = fir.convert %[[zBoxDecl]]#0 : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> !fir.ref<!fir.box<none>>
! CHECK-NOT: fir.call @{{.*}}AllocatableSetBounds
! CHECK: fir.call @{{.*}}AllocatableAllocate
! Check that y descriptor is read when referencing it.
- ! CHECK: %[[yBoxLoad:.*]] = fir.load %[[yBoxDecl]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>
- ! CHECK-DAG: %[[yAddr:.*]] = fir.box_addr %[[yBoxLoad]] : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>) -> !fir.heap<!fir.array<?x?xf32>>
- ! CHECK-DAG: %[[yBounds1:.*]]:3 = fir.box_dims %[[yBoxLoad]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[yBounds2:.*]]:3 = fir.box_dims %[[yBoxLoad]], %c1{{.*}} : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index) -> (index, index, index)
+ ! CHECK: %[[yBoxLoad:.*]] = fir.load %[[yBoxDecl]]#0 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xf32>>>>
+ ! CHECK: hlfir.designate %[[yBoxLoad]] (%{{.*}}, %{{.*}}) : (!fir.box<!fir.heap<!fir.array<?x?xf32>>>, index, index) -> !fir.ref<f32>
print *, x, y(45, 46), z
deallocate(x, y, z)
- ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%[[xBoxCast2]], {{.*}})
- ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%[[yBoxCast]], {{.*}})
- ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%[[zBoxCast]], {{.*}})
+ ! CHECK: fir.call @{{.*}}AllocatableDeallocate
+ ! CHECK: fir.call @{{.*}}AllocatableDeallocate
+ ! CHECK: fir.call @{{.*}}AllocatableDeallocate
end subroutine
! test lowering of character allocatables
-! CHECK-LABEL: _QPchar_deferred(
+! CHECK-LABEL: func.func @_QPchar_deferred(
subroutine char_deferred(n)
integer :: n
character(:), allocatable :: scalar, array(:)
- ! CHECK-DAG: %[[nArgDecl:.*]] = fir.declare %arg0 {{.*}}
+ ! CHECK-DAG: %[[nArgDecl:.*]]:2 = hlfir.declare %arg0 {{.*}}
! CHECK-DAG: %[[sBoxAddr:.*]] = fir.alloca !fir.box<!fir.heap<!fir.char<1,?>>> {{{.*}}uniq_name = "_QFchar_deferredEscalar"}
- ! CHECK-DAG: %[[sBoxDecl:.*]] = fir.declare %[[sBoxAddr]]{{.*}}
+ ! CHECK-DAG: %[[sBoxDecl:.*]]:2 = hlfir.declare %[[sBoxAddr]]{{.*}}
! CHECK-DAG: %[[aBoxAddr:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>> {{{.*}}uniq_name = "_QFchar_deferredEarray"}
- ! CHECK-DAG: %[[aBoxDecl:.*]] = fir.declare %[[aBoxAddr]]{{.*}}
+ ! CHECK-DAG: %[[aBoxDecl:.*]]:2 = hlfir.declare %[[aBoxAddr]]{{.*}}
allocate(character(10):: scalar, array(30))
- ! CHECK-DAG: %[[sBoxCast1:.*]] = fir.convert %[[sBoxDecl]] : (!fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[sBoxCast1:.*]] = fir.convert %[[sBoxDecl]]#0 : (!fir.ref<!fir.box<!fir.heap<!fir.char<1,?>>>>) -> !fir.ref<!fir.box<none>>
! CHECK-DAG: %[[ten1:.*]] = fir.convert %c10{{.*}} : (i32) -> i64
! CHECK: fir.call @{{.*}}AllocatableInitCharacterForAllocate(%[[sBoxCast1]], %[[ten1]], %c1{{.*}}, %c0{{.*}}, %c0{{.*}})
! CHECK-NOT: AllocatableSetBounds
- ! CHECK: fir.call @{{.*}}AllocatableAllocate(%[[sBoxCast1]]
+ ! CHECK: fir.call @{{.*}}AllocatableAllocate(%{{.*}}
- ! CHECK-DAG: %[[aBoxCast1:.*]] = fir.convert %[[aBoxDecl]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK-DAG: %[[aBoxCast1:.*]] = fir.convert %[[aBoxDecl]]#0 : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>) -> !fir.ref<!fir.box<none>>
! CHECK: fir.call @{{.*}}AllocatableInitCharacterForAllocate(%[[aBoxCast1]], %{{.*}}, %c1{{.*}}, %c1{{.*}}, %c0{{.*}})
- ! CHECK: fir.call @{{.*}}AllocatableSetBounds(%[[aBoxCast1]]
- ! CHECK: fir.call @{{.*}}AllocatableAllocate(%[[aBoxCast1]]
+ ! CHECK: fir.call @{{.*}}AllocatableSetBounds(%{{.*}}
+ ! CHECK: fir.call @{{.*}}AllocatableAllocate(%{{.*}}
deallocate(scalar, array)
- ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%[[sBoxCast1]], {{.*}})
- ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%[[aBoxCast1]], {{.*}})
+ ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%{{.*}}, {{.*}})
+ ! CHECK: fir.call @{{.*}}AllocatableDeallocate(%{{.*}}, {{.*}})
! only testing that the correct length is set in the descriptor.
allocate(character(n):: scalar, array(40))
- ! CHECK-DAG: %[[n:.*]] = fir.load %[[nArgDecl]] : !fir.ref<i32>
+ ! CHECK-DAG: %[[n:.*]] = fir.load %[[nArgDecl]]#0 : !fir.ref<i32>
! CHECK-DAG: %[[ncast1:.*]] = fir.convert %[[n]] : (i32) -> i64
- ! CHECK: fir.call @{{.*}}AllocatableInitCharacterForAllocate(%[[sBoxCast1]], %[[ncast1]], %c1{{.*}}, %c0{{.*}}, %c0{{.*}})
- ! CHECK: fir.call @{{.*}}AllocatableInitCharacterForAllocate(%[[aBoxCast1]], %[[n...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/197973
More information about the flang-commits
mailing list