[flang-commits] [flang] [flang][NFC] Converted five tests from old lowering to new lowering (part 8) (PR #175881)
via flang-commits
flang-commits at lists.llvm.org
Tue Jan 13 20:01:09 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-flang-fir-hlfir
Author: Eugene Epshteyn (eugeneepshteyn)
<details>
<summary>Changes</summary>
Tests converted from test/Lower: block.f90, call-copy-in-out.f90, call-implicit.f90, call.f90, character-compare.f90
---
Patch is 31.45 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/175881.diff
5 Files Affected:
- (modified) flang/test/Lower/block.f90 (+32-31)
- (modified) flang/test/Lower/call-copy-in-out.f90 (+53-191)
- (modified) flang/test/Lower/call-implicit.f90 (+10-4)
- (modified) flang/test/Lower/call.f90 (+13-10)
- (modified) flang/test/Lower/character-compare.f90 (+2-3)
``````````diff
diff --git a/flang/test/Lower/block.f90 b/flang/test/Lower/block.f90
index d2bc90ef6c671..c36f98a4ca313 100644
--- a/flang/test/Lower/block.f90
+++ b/flang/test/Lower/block.f90
@@ -1,66 +1,66 @@
-! RUN: bbc -emit-fir -hlfir=false -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
! CHECK-LABEL: func @_QQmain
program bb ! block stack management and exits
- ! CHECK: %[[V_0:[0-9]+]] = fir.alloca i32 {adapt.valuebyref}
! CHECK: %[[V_1:[0-9]+]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
+ ! CHECK: %[[V_I:[0-9]+]]:2 = hlfir.declare %[[V_1]] {uniq_name = "_QFEi"}
integer :: i, j
- ! CHECK: fir.store %c0{{.*}} to %[[V_1]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %c0{{.*}} to %[[V_I]]#0
i = 0
! CHECK: %[[V_3:[0-9]+]] = llvm.intr.stacksave : !llvm.ptr
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: br ^bb1
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.br ^bb1
! CHECK: ^bb1: // 2 preds: ^bb0, ^bb16
- ! CHECK: cond_br %{{.*}}, ^bb2, ^bb17
+ ! CHECK: cf.cond_br %{{.*}}, ^bb2, ^bb17
! CHECK: ^bb2: // pred: ^bb1
! CHECK: %[[V_11:[0-9]+]] = llvm.intr.stacksave : !llvm.ptr
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb3, ^bb4
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb3, ^bb4
! CHECK: ^bb3: // pred: ^bb2
- ! CHECK: br ^bb10
+ ! CHECK: cf.br ^bb10
! CHECK: ^bb4: // pred: ^bb2
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb5, ^bb6
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb5, ^bb6
! CHECK: ^bb5: // pred: ^bb4
- ! CHECK: br ^bb14
+ ! CHECK: cf.br ^bb14
! CHECK: ^bb6: // pred: ^bb4
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb7, ^bb8
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb7, ^bb8
! CHECK: ^bb7: // pred: ^bb6
! CHECK: llvm.intr.stackrestore %[[V_11]] : !llvm.ptr
- ! CHECK: br ^bb15
+ ! CHECK: cf.br ^bb15
! CHECK: ^bb8: // pred: ^bb6
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb9, ^bb10
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb9, ^bb10
! CHECK: ^bb9: // pred: ^bb8
! CHECK: llvm.intr.stackrestore %[[V_11]] : !llvm.ptr
- ! CHECK: br ^bb16
+ ! CHECK: cf.br ^bb16
! CHECK: ^bb10: // 2 preds: ^bb3, ^bb8
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb11, ^bb12
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb11, ^bb12
! CHECK: ^bb11: // pred: ^bb10
! CHECK: llvm.intr.stackrestore %[[V_11]] : !llvm.ptr
- ! CHECK: br ^bb18
+ ! CHECK: cf.br ^bb18
! CHECK: ^bb12: // pred: ^bb10
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
- ! CHECK: cond_br %{{.*}}, ^bb13, ^bb14
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
+ ! CHECK: cf.cond_br %{{.*}}, ^bb13, ^bb14
! CHECK: ^bb13: // pred: ^bb12
! CHECK: llvm.intr.stackrestore %[[V_11]] : !llvm.ptr
! CHECK: llvm.intr.stackrestore %[[V_3]] : !llvm.ptr
- ! CHECK: br ^bb19
+ ! CHECK: cf.br ^bb19
! CHECK: ^bb14: // 2 preds: ^bb5, ^bb12
! CHECK: llvm.intr.stackrestore %[[V_11]] : !llvm.ptr
- ! CHECK: br ^bb15
+ ! CHECK: cf.br ^bb15
! CHECK: ^bb15: // 2 preds: ^bb7, ^bb14
- ! CHECK: br ^bb16
+ ! CHECK: cf.br ^bb16
! CHECK: ^bb16: // 2 preds: ^bb9, ^bb15
- ! CHECK: br ^bb1
+ ! CHECK: cf.br ^bb1
! CHECK: ^bb17: // pred: ^bb1
- ! CHECK: fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
+ ! CHECK: hlfir.assign %{{.*}} to %[[V_I]]#0
! CHECK: cf.br ^bb18
! CHECK: ^bb18: // 2 preds: ^bb11, ^bb17
! CHECK: llvm.intr.stackrestore %[[V_3]] : !llvm.ptr
- ! CHECK: br ^bb19
+ ! CHECK: cf.br ^bb19
! CHECK: ^bb19: // 2 preds: ^bb13, ^bb18
block
i = i + 1 ! 1 increment
@@ -80,8 +80,9 @@ program bb ! block stack management and exits
100 print*, i ! expect 21
! CHECK: %[[V_51:[0-9]+]] = llvm.intr.stacksave : !llvm.ptr
- ! CHECK: fir.store %c5{{.*}} to %[[V_0]] : !fir.ref<i32>
- ! CHECK: fir.call @ss(%[[V_0]]) proc_attrs<bind_c> fastmath<contract> : (!fir.ref<i32>) -> ()
+ ! CHECK: %[[ASSOC:[0-9]+]]:3 = hlfir.associate %c5{{.*}} {adapt.valuebyref} : (i32) -> (!fir.ref<i32>, !fir.ref<i32>, i1)
+ ! CHECK: fir.call @ss(%[[ASSOC]]#0) proc_attrs<bind_c> fastmath<contract> : (!fir.ref<i32>) -> ()
+ ! CHECK: hlfir.end_associate %[[ASSOC]]#1, %[[ASSOC]]#2 : !fir.ref<i32>, i1
! CHECK: llvm.intr.stackrestore %[[V_51]] : !llvm.ptr
block
interface
diff --git a/flang/test/Lower/call-copy-in-out.f90 b/flang/test/Lower/call-copy-in-out.f90
index 65141dcb7c5fe..fa2182ac11bac 100644
--- a/flang/test/Lower/call-copy-in-out.f90
+++ b/flang/test/Lower/call-copy-in-out.f90
@@ -1,107 +1,60 @@
! Test copy-in / copy-out of non-contiguous variable passed as F77 array arguments.
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
! Nominal test
! CHECK-LABEL: func @_QPtest_assumed_shape_to_array(
! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
subroutine test_assumed_shape_to_array(x)
real :: x(:)
-
-! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
-! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]] -> (!fir.heap<!fir.array<?xf32>>) {
-! CHECK: %[[box_addr:.*]] = fir.box_addr %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.heap<!fir.array<?xf32>>
-! CHECK: fir.result %[[box_addr]] : !fir.heap<!fir.array<?xf32>>
-! CHECK: } else {
-! Creating temp
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x:.*]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".copyinout"}
-
-! Copy-in
-! CHECK-DAG: %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
-! CHECK-DAG: %[[temp_box:.*]] = fir.embox %[[temp]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
-! CHECK-DAG: fir.store %[[temp_box]] to %[[temp_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
-! CHECK-DAG: %[[temp_box_addr:.*]] = fir.convert %[[temp_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
-! CHECK-DAG: %[[arg_box:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK-DAG: fir.call @_FortranAAssignTemporary(%[[temp_box_addr]], %[[arg_box]], %{{.*}}, %{{.*}}){{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
-! CHECK: fir.result %[[temp]] : !fir.heap<!fir.array<?xf32>>
-
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
-! CHECK: fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
-
-! Copy-out
-! CHECK-DAG: %[[shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
-! CHECK-DAG: %[[temp_box:.*]] = fir.embox %[[addr]](%[[shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
-! CHECK: %[[rebox:.*]] = fir.rebox %[[temp_box]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<!fir.heap<!fir.array<?xf32>>>
-! CHECK: fir.store %[[rebox]] to %[[temp_box_ref:.*]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>
-! CHECK-DAG: fir.store %[[x]] to %[[arg_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
-! CHECK-DAG: %[[arg_box_addr:.*]] = fir.convert %[[arg_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
-! CHECK-DAG: %[[temp_box_cast:.*]] = fir.convert %[[temp_box_ref]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xf32>>>>) -> !fir.ref<!fir.box<none>>
-! CHECK-DAG: fir.call @_FortranACopyOutAssign(%[[arg_box_addr]], %[[temp_box_cast]], %{{.*}}, %{{.*}}){{.*}}: (!fir.ref<!fir.box<none>>, !fir.ref<!fir.box<none>>, !fir.ref<i8>, i32) -> ()
-
+! CHECK: %[[x_decl:.*]]:2 = hlfir.declare %[[x]]
+! CHECK: %[[copy_in:.*]]:2 = hlfir.copy_in %[[x_decl]]#0 {{.*}}
+! CHECK: %[[addr:.*]] = fir.box_addr %[[copy_in]]#0
+! CHECK: fir.call @_QPbar(%[[addr]])
+! CHECK: hlfir.copy_out %{{.*}}, %[[copy_in]]#1 to %[[x_decl]]#0
call bar(x)
end subroutine
! Test that copy-in/copy-out does not trigger the re-evaluation of
! the designator expression.
! CHECK-LABEL: func @_QPeval_expr_only_once(
-! CHECK-SAME: %[[x:.*]]: !fir.ref<!fir.array<200xf32>>{{.*}}) {
subroutine eval_expr_only_once(x)
integer :: only_once
real :: x(200)
! CHECK: fir.call @_QPonly_once()
-! CHECK: %[[x_section:.*]] = fir.embox %[[x]](%{{.*}}) [%{{.*}}] : (!fir.ref<!fir.array<200xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
-! CHECK: %[[box_none:.*]] = fir.convert %[[x_section]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
-! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]] -> (!fir.heap<!fir.array<?xf32>>) {
-
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>
-! CHECK-NOT: fir.call @_QPonly_once()
-! CHECK: fir.call @_FortranAAssignTemporary
+! CHECK: hlfir.designate
+! CHECK: hlfir.copy_in
! CHECK-NOT: fir.call @_QPonly_once()
-
-! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
-! CHECK: fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
- call bar(x(1:200:only_once()))
-
+! CHECK: fir.call @_QPbar
! CHECK-NOT: fir.call @_QPonly_once()
-! CHECK: fir.call @_FortranACopyOutAssign
+! CHECK: hlfir.copy_out
! CHECK-NOT: fir.call @_QPonly_once()
-
+ call bar(x(1:200:only_once()))
end subroutine
! Test no copy-in/copy-out is generated for contiguous assumed shapes.
! CHECK-LABEL: func @_QPtest_contiguous(
-! CHECK-SAME: %[[x:.*]]: !fir.box<!fir.array<?xf32>>
subroutine test_contiguous(x)
real, contiguous :: x(:)
-! CHECK: %[[addr:.*]] = fir.box_addr %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
-! CHECK-NOT: fir.call @_FortranAAssignTemporary
-! CHECK: fir.call @_QPbar(%[[addr]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
+! CHECK-NOT: hlfir.copy_in
+! CHECK: fir.call @_QPbar
+! CHECK-NOT: hlfir.copy_out
call bar(x)
-! CHECK-NOT: fir.call @_FortranACopyOutAssign
-! CHECK: return
end subroutine
! Test the parenthesis are preventing copy-out.
-! CHECK: func @_QPtest_parenthesis(
-! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
+! CHECK-LABEL: func @_QPtest_parenthesis(
subroutine test_parenthesis(x)
real :: x(:)
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1 {uniq_name = ".array.expr"}
-! CHECK: fir.array_merge_store %{{.*}}, %{{.*}} to %[[temp]]
-! CHECK: %[[cast:.*]] = fir.convert %[[temp]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<?xf32>>
-! CHECK: fir.call @_QPbar(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<?xf32>>) -> ()
+! CHECK: hlfir.elemental
+! CHECK: hlfir.associate
+! CHECK: fir.call @_QPbar
+! CHECK: hlfir.end_associate
+! CHECK-NOT: hlfir.copy_out
call bar((x))
-! CHECK-NOT: fir.call @_FortranACopyOutAssign
-! CHECK: return
end subroutine
! Test copy-in in is skipped for intent(out) arguments.
-! CHECK: func @_QPtest_intent_out(
-! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
+! CHECK-LABEL: func @_QPtest_intent_out(
subroutine test_intent_out(x)
real :: x(:)
interface
@@ -109,26 +62,14 @@ subroutine bar_intent_out(x)
real, intent(out) :: x(100)
end subroutine
end interface
-! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
-! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
-! CHECK: } else {
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
-! CHECK-NOT: fir.call @_FortranAAssignTemporary
-! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
-! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
-! CHECK: fir.call @_QPbar_intent_out(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
+! CHECK: hlfir.copy_in
+! CHECK: fir.call @_QPbar_intent_out
+! CHECK: hlfir.copy_out
call bar_intent_out(x)
-
-! CHECK: fir.if %[[not_contiguous]]
-! CHECK: fir.call @_FortranACopyOutAssign
-! CHECK: return
end subroutine
! Test copy-out is skipped for intent(out) arguments.
! CHECK-LABEL: func.func @_QPtest_intent_in(
-! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
subroutine test_intent_in(x)
real :: x(:)
interface
@@ -136,30 +77,15 @@ subroutine bar_intent_in(x)
real, intent(in) :: x(100)
end subroutine
end interface
-! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
-! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
-! CHECK: } else {
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
-! CHECK: %[[temp_shape:.*]] = fir.shape %[[dim]]#1 : (index) -> !fir.shape<1>
-! CHECK: %[[temp_box:.*]] = fir.embox %[[temp]](%[[temp_shape]]) : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<?xf32>>
-! CHECK: fir.store %[[temp_box]] to %[[temp_box_loc:.*]] : !fir.ref<!fir.box<!fir.array<?xf32>>>
-! CHECK: %[[temp_box_addr:.*]] = fir.convert %[[temp_box_loc]] : (!fir.ref<!fir.box<!fir.array<?xf32>>>) -> !fir.ref<!fir.box<none>>
-! CHECK: fir.call @_FortranAAssignTemporary(%[[temp_box_addr]],
-! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
-! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
-! CHECK: fir.call @_QPbar_intent_in(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
+! CHECK: hlfir.copy_in
+! CHECK: fir.call @_QPbar_intent_in
+! CHECK: hlfir.copy_out
+! CHECK-SAME: ) -> ()
call bar_intent_in(x)
-! CHECK: fir.if %[[not_contiguous]]
-! CHECK: fir.zero
-! CHECK: fir.call @_FortranACopyOutAssign
-! CHECK: return
end subroutine
! Test copy-in/copy-out is done for intent(inout)
-! CHECK: func @_QPtest_intent_inout(
-! CHECK: %[[x:.*]]: !fir.box<!fir.array<?xf32>>{{.*}}) {
+! CHECK-LABEL: func @_QPtest_intent_inout(
subroutine test_intent_inout(x)
real :: x(:)
interface
@@ -167,111 +93,55 @@ subroutine bar_intent_inout(x)
real, intent(inout) :: x(100)
end subroutine
end interface
-! CHECK: %[[box_none:.*]] = fir.convert %[[x]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[is_contiguous:.*]] = fir.call @_FortranAIsContiguous(%[[box_none]]) {{.*}}: (!fir.box<none>) -> i1
-! CHECK: %[[addr:.*]] = fir.if %[[is_contiguous]]
-! CHECK: } else {
-! CHECK: %[[dim:.*]]:3 = fir.box_dims %[[x]], %c0{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
-! CHECK: %[[temp:.*]] = fir.allocmem !fir.array<?xf32>, %[[dim]]#1
-! CHECK: fir.call @_FortranAAssign
-! CHECK: %[[not_contiguous:.*]] = arith.cmpi eq, %[[is_contiguous]], %false{{.*}} : i1
-! CHECK: %[[cast:.*]] = fir.convert %[[addr]] : (!fir.heap<!fir.array<?xf32>>) -> !fir.ref<!fir.array<100xf32>>
-! CHECK: fir.call @_QPbar_intent_inout(%[[cast]]) {{.*}}: (!fir.ref<!fir.array<100xf32>>) -> ()
+! CHECK: hlfir.copy_in
+! CHECK: fir.call @_QPbar_intent_inout
+! CHECK: hlfir.copy_out
+! CHECK-SAME: to
call bar_intent_inout(x)
-! CHECK: fir.if %[[not_contiguous]]
-! CHECK: fir.call @_FortranACopyOutAssign
-! CHECK: return
end subroutine
! Test characters are handled correctly
! CHECK-LABEL: func @_QPtest_char(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.box<!fir.array<?x!fir.char<1,10>>>{{.*}}) {
subroutine test_char(x)
-! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.array<?x!fir.char<1,10>>>
-! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.box<!fir.array<?x!fir.char<1,10>>>
-! CHECK: %[[VAL_3:.*]] = arith.constant 10 : index
-! CHECK: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<none>
-! CHECK: %[[VAL_5:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_4]]) fastmath<contract> : (!fir.box<none>) -> i1
-! CHECK: %[[VAL_6:.*]] = fir.if %[[VAL_5]] -> (!fir.heap<!fir.array<?x!fir.char<1,10>>>) {
-! CHECK: %[[VAL_7:.*]] = fir.box_addr %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.heap<!fir.array<?x!fir.char<1,10>>>
-! CHECK: fir.result %[[VAL_7]] : !fir.heap<!fir.array<?x!fir.char<1,10>>>
-! CHECK: } else {
-! CHECK: %[[VAL_8:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_9:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_8]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
-! CHECK: %[[VAL_10:.*]] = fir.allocmem !fir.array<?x!fir.char<1,10>>, %[[VAL_9]]#1 {uniq_name = ".copyinout"}
-! CHECK: %[[VAL_11:.*]] = fir.shape %[[VAL_9]]#1 : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_12:.*]] = fir.embox %[[VAL_10]](%[[VAL_11]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
-! CHECK: fir.store %[[VAL_12]] to %[[VAL_2]] : !fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>) -> !fir.ref<!fir.box<none>>
-! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<none>
-! CHECK: fir.call @_FortranAAssignTemporary(%[[VAL_15]], %[[VAL_16]], %{{.*}}, %{{.*}}) fastmath<contract> : (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
-! CHECK: fir.result %[[VAL_10]] : !fir.heap<!fir.array<?x!fir.char<1,10>>>
-! CHECK: }
-! CHECK: %[[VAL_19:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_20:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_19]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>, index) -> (index, index, index)
-! CHECK: %[[VAL_21:.*]] = arith.constant false
-! CHECK: %[[VAL_22:.*]] = arith.cmpi eq, %[[VAL_5]], %[[VAL_21]] : i1
-! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_24:.*]] : (!fir.heap<!fir.array<?x!fir.char<1,10>>>) -> !fir.ref<!fir.char<1,?>>
-! CHECK: %[[VAL_25:.*]] = fir.emboxchar %[[VAL_23]], %[[VAL_3]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
-! CHECK: fir.call @_QPbar_char(%[[VAL_25]]) fastmath<contract> : (!fir.boxchar<1>) -> ()
-! CHECK: fir.if %[[VAL_22]] {
-! CHECK: %[[VAL_26:.*]] = fir.shape %[[VAL_20]]#1 : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_27:.*]] = fir.embox %[[VAL_24]](%[[VAL_26]]) : (!fir.heap<!fir.array<?x!fir.char<1,10>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.char<1,10>>>
-! CHECK: %[[REBOX:.*]] = fir.rebox %[[VAL_27]] : (!fir.box<!fir.array<?x!fir.char<1,10>>>) -> !fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>
-! CHECK: fir.store %[[REBOX]] to %[[TMP_BOX_REF:.*]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,10>>>>>
-! CHECK: fir.store %[[VAL_0]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.array<?x!fir.char<1,10>>>>
-! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.box<!fi...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/175881
More information about the flang-commits
mailing list