[flang-commits] [flang] cd6119c - [flang][NFC] Converted more tests from old lowering to new lowering (part 55) (#195291)
via flang-commits
flang-commits at lists.llvm.org
Sun May 3 19:19:45 PDT 2026
Author: Eugene Epshteyn
Date: 2026-05-03T22:19:40-04:00
New Revision: cd6119c00b461c36139f1f4a0ca1653a6ab2a32b
URL: https://github.com/llvm/llvm-project/commit/cd6119c00b461c36139f1f4a0ca1653a6ab2a32b
DIFF: https://github.com/llvm/llvm-project/commit/cd6119c00b461c36139f1f4a0ca1653a6ab2a32b.diff
LOG: [flang][NFC] Converted more tests from old lowering to new lowering (part 55) (#195291)
Converted tests:
- Lower/Intrinsics/ieee_unordered.f90
- Lower/Intrinsics/rrspacing.f90
- Lower/structure-constructors.f90
- Lower/transformational-intrinsics.f90
Removed test:
- Transforms/stack-arrays.f90: tested the stack-arrays pass on the
legacy --array-value-copy output of legacy lowering. The HLFIR pipeline
produces fundamentally different code for array slice copies
(_FortranAAssign with fir.embox of sub-slices instead of allocating a
temp via array-value-copy), so the test's premises no longer apply. The
HLFIR equivalent test already exists at
Transforms/stack-arrays-hlfir.f90.
Added:
Modified:
flang/test/Lower/Intrinsics/ieee_unordered.f90
flang/test/Lower/Intrinsics/rrspacing.f90
flang/test/Lower/structure-constructors.f90
flang/test/Lower/transformational-intrinsics.f90
Removed:
flang/test/Transforms/stack-arrays.f90
################################################################################
diff --git a/flang/test/Lower/Intrinsics/ieee_unordered.f90 b/flang/test/Lower/Intrinsics/ieee_unordered.f90
index 18bb2b0009ed9..6e2d40b3f4c32 100644
--- a/flang/test/Lower/Intrinsics/ieee_unordered.f90
+++ b/flang/test/Lower/Intrinsics/ieee_unordered.f90
@@ -1,60 +1,58 @@
! REQUIRES: flang-supports-f128-math
-! RUN: bbc -emit-fir -hlfir=false -o - %s | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck %s
! CHECK-LABEL: func @_QQmain
use ieee_arithmetic
-! CHECK-DAG: %[[V_0:[0-9]+]] = fir.alloca !fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>
-! CHECK-DAG: %[[V_1:[0-9]+]] = fir.alloca !fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>
-! CHECK-DAG: %[[V_2:[0-9]+]] = fir.alloca f128 {bindc_name = "x", uniq_name = "_QFEx"}
-! CHECK-DAG: %[[V_3:[0-9]+]] = fir.alloca f128 {bindc_name = "y", uniq_name = "_QFEy"}
-! CHECK-DAG: %[[V_4:[0-9]+]] = fir.alloca f128 {bindc_name = "z", uniq_name = "_QFEz"}
+! CHECK-DAG: %[[V_X:[0-9]+]] = fir.alloca f128 {bindc_name = "x", uniq_name = "_QFEx"}
+! CHECK-DAG: %[[X_DECL:[0-9]+]]:2 = hlfir.declare %[[V_X]] {uniq_name = "_QFEx"}
+! CHECK-DAG: %[[V_Y:[0-9]+]] = fir.alloca f128 {bindc_name = "y", uniq_name = "_QFEy"}
+! CHECK-DAG: %[[Y_DECL:[0-9]+]]:2 = hlfir.declare %[[V_Y]] {uniq_name = "_QFEy"}
+! CHECK-DAG: %[[V_Z:[0-9]+]] = fir.alloca f128 {bindc_name = "z", uniq_name = "_QFEz"}
+! CHECK-DAG: %[[Z_DECL:[0-9]+]]:2 = hlfir.declare %[[V_Z]] {uniq_name = "_QFEz"}
real(16) :: x, y, z
x = -17.0
-! CHECK: %[[V_11:[0-9]+]] = fir.coordinate_of %[[V_1]], _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
-! CHECK: fir.store %c3{{.*}} to %[[V_11]] : !fir.ref<i8>
-
-! CHECK: %[[V_13:[0-9]+]] = fir.coordinate_of %[[V_1]], _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
-! CHECK: %[[V_14:[0-9]+]] = fir.load %[[V_13]] : !fir.ref<i8>
-! CHECK: %[[V_15:[0-9]+]] = fir.address_of(@_FortranAIeeeValueTable_16) : !fir.ref<!fir.array<12xi64>>
-! CHECK: %[[V_16:[0-9]+]] = fir.coordinate_of %[[V_15]], %[[V_14]] : (!fir.ref<!fir.array<12xi64>>, i8) -> !fir.ref<i64>
-! CHECK: %[[V_17:[0-9]+]] = fir.load %[[V_16]] : !fir.ref<i64>
-! CHECK: %[[V_18:[0-9]+]] = fir.convert %[[V_17]] : (i64) -> i128
-! CHECK: %[[V_19:[0-9]+]] = arith.shli %[[V_18]], %c64{{.*}} : i128
-! CHECK: %[[V_20:[0-9]+]] = arith.bitcast %[[V_19]] : i128 to f128
-! CHECK: fir.store %[[V_20]] to %[[V_3]] : !fir.ref<f128>
+! CHECK: %[[V_NEG_INF:[0-9]+]]:2 = hlfir.declare %{{.*}} {{{.*}}uniq_name = "_QQro._QMieee_arithmeticTieee_class_type.{{[0-9]+}}"}
+! CHECK: %[[V_11:[0-9]+]] = fir.coordinate_of %[[V_NEG_INF]]#0, _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
+! CHECK: %[[V_12:[0-9]+]] = fir.load %[[V_11]] : !fir.ref<i8>
+! CHECK: %[[V_13:[0-9]+]] = fir.address_of(@_FortranAIeeeValueTable_16) : !fir.ref<!fir.array<12xi64>>
+! CHECK: %[[V_14:[0-9]+]] = fir.coordinate_of %[[V_13]], %[[V_12]] : (!fir.ref<!fir.array<12xi64>>, i8) -> !fir.ref<i64>
+! CHECK: %[[V_15:[0-9]+]] = fir.load %[[V_14]] : !fir.ref<i64>
+! CHECK: %[[V_16:[0-9]+]] = fir.convert %[[V_15]] : (i64) -> i128
+! CHECK: %[[V_17:[0-9]+]] = arith.shli %[[V_16]], %c64{{.*}} : i128
+! CHECK: %[[V_18:[0-9]+]] = arith.bitcast %[[V_17]] : i128 to f128
+! CHECK: hlfir.assign %[[V_18]] to %[[Y_DECL]]#0 : f128, !fir.ref<f128>
y = ieee_value(y, ieee_negative_inf)
-! CHECK: %[[V_27:[0-9]+]] = fir.coordinate_of %[[V_0]], _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
-! CHECK: fir.store %c2{{.*}} to %[[V_27]] : !fir.ref<i8>
-! CHECK: %[[V_29:[0-9]+]] = fir.coordinate_of %[[V_0]], _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
-! CHECK: %[[V_30:[0-9]+]] = fir.load %[[V_29]] : !fir.ref<i8>
-! CHECK: %[[V_31:[0-9]+]] = fir.address_of(@_FortranAIeeeValueTable_16) : !fir.ref<!fir.array<12xi64>>
-! CHECK: %[[V_32:[0-9]+]] = fir.coordinate_of %[[V_31]], %[[V_30]] : (!fir.ref<!fir.array<12xi64>>, i8) -> !fir.ref<i64>
-! CHECK: %[[V_33:[0-9]+]] = fir.load %[[V_32]] : !fir.ref<i64>
-! CHECK: %[[V_34:[0-9]+]] = fir.convert %[[V_33]] : (i64) -> i128
-! CHECK: %[[V_35:[0-9]+]] = arith.shli %[[V_34]], %c64{{.*}} : i128
-! CHECK: %[[V_36:[0-9]+]] = arith.bitcast %[[V_35]] : i128 to f128
-! CHECK: fir.store %[[V_36]] to %[[V_4]] : !fir.ref<f128>
+! CHECK: %[[V_QNAN:[0-9]+]]:2 = hlfir.declare %{{.*}} {{{.*}}uniq_name = "_QQro._QMieee_arithmeticTieee_class_type.{{[0-9]+}}"}
+! CHECK: %[[V_27:[0-9]+]] = fir.coordinate_of %[[V_QNAN]]#0, _QMieee_arithmeticTieee_class_type.which : (!fir.ref<!fir.type<_QMieee_arithmeticTieee_class_type{_QMieee_arithmeticTieee_class_type.which:i8}>>) -> !fir.ref<i8>
+! CHECK: %[[V_28:[0-9]+]] = fir.load %[[V_27]] : !fir.ref<i8>
+! CHECK: %[[V_29:[0-9]+]] = fir.address_of(@_FortranAIeeeValueTable_16) : !fir.ref<!fir.array<12xi64>>
+! CHECK: %[[V_30:[0-9]+]] = fir.coordinate_of %[[V_29]], %[[V_28]] : (!fir.ref<!fir.array<12xi64>>, i8) -> !fir.ref<i64>
+! CHECK: %[[V_31:[0-9]+]] = fir.load %[[V_30]] : !fir.ref<i64>
+! CHECK: %[[V_32:[0-9]+]] = fir.convert %[[V_31]] : (i64) -> i128
+! CHECK: %[[V_33:[0-9]+]] = arith.shli %[[V_32]], %c64{{.*}} : i128
+! CHECK: %[[V_34:[0-9]+]] = arith.bitcast %[[V_33]] : i128 to f128
+! CHECK: hlfir.assign %[[V_34]] to %[[Z_DECL]]#0 : f128, !fir.ref<f128>
z = ieee_value(z, ieee_quiet_nan)
-! CHECK: %[[V_40:[0-9]+]] = fir.load %[[V_2]] : !fir.ref<f128>
-! CHECK: %[[V_41:[0-9]+]] = fir.load %[[V_3]] : !fir.ref<f128>
+! CHECK: %[[V_40:[0-9]+]] = fir.load %[[X_DECL]]#0 : !fir.ref<f128>
+! CHECK: %[[V_41:[0-9]+]] = fir.load %[[Y_DECL]]#0 : !fir.ref<f128>
! CHECK: %[[V_44:[0-9]+]] = arith.cmpf uno, %[[V_40]], %[[V_41]] {{.*}} : f128
! CHECK: %[[V_45:[0-9]+]] = fir.convert %[[V_44]] : (i1) -> !fir.logical<4>
! CHECK: %[[V_46:[0-9]+]] = fir.convert %[[V_45]] : (!fir.logical<4>) -> i1
! CHECK: %[[V_47:[0-9]+]] = fir.call @_FortranAioOutputLogical(%{{.*}}, %[[V_46]]) {{.*}} : (!fir.ref<i8>, i1) -> i1
-! CHECK: %[[V_48:[0-9]+]] = fir.load %[[V_2]] : !fir.ref<f128>
-! CHECK: %[[V_49:[0-9]+]] = fir.load %[[V_4]] : !fir.ref<f128>
+! CHECK: %[[V_48:[0-9]+]] = fir.load %[[X_DECL]]#0 : !fir.ref<f128>
+! CHECK: %[[V_49:[0-9]+]] = fir.load %[[Z_DECL]]#0 : !fir.ref<f128>
! CHECK: %[[V_52:[0-9]+]] = arith.cmpf uno, %[[V_48]], %[[V_49]] {{.*}} : f128
! CHECK: %[[V_53:[0-9]+]] = fir.convert %[[V_52]] : (i1) -> !fir.logical<4>
! CHECK: %[[V_54:[0-9]+]] = fir.convert %[[V_53]] : (!fir.logical<4>) -> i1
! CHECK: %[[V_55:[0-9]+]] = fir.call @_FortranAioOutputLogical(%{{.*}}, %[[V_54]]) {{.*}} : (!fir.ref<i8>, i1) -> i1
-! CHECK: %[[V_56:[0-9]+]] = fir.load %[[V_3]] : !fir.ref<f128>
-! CHECK: %[[V_57:[0-9]+]] = fir.load %[[V_4]] : !fir.ref<f128>
+! CHECK: %[[V_56:[0-9]+]] = fir.load %[[Y_DECL]]#0 : !fir.ref<f128>
+! CHECK: %[[V_57:[0-9]+]] = fir.load %[[Z_DECL]]#0 : !fir.ref<f128>
! CHECK: %[[V_60:[0-9]+]] = arith.cmpf uno, %[[V_56]], %[[V_57]] {{.*}} : f128
! CHECK: %[[V_61:[0-9]+]] = fir.convert %[[V_60]] : (i1) -> !fir.logical<4>
! CHECK: %[[V_62:[0-9]+]] = fir.convert %[[V_61]] : (!fir.logical<4>) -> i1
diff --git a/flang/test/Lower/Intrinsics/rrspacing.f90 b/flang/test/Lower/Intrinsics/rrspacing.f90
index 5cfd7c7befdc4..8646068a421e5 100644
--- a/flang/test/Lower/Intrinsics/rrspacing.f90
+++ b/flang/test/Lower/Intrinsics/rrspacing.f90
@@ -1,12 +1,12 @@
! REQUIRES: flang-supports-f128-math
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! CHECK-LABEL: func @_QPrrspacing_test2(
-! CHECK-SAME: %[[x:[^:]+]]: !fir.ref<f128>{{.*}}) -> f128
+! CHECK-SAME: %[[arg0:[^:]+]]: !fir.ref<f128>{{.*}}) -> f128
real*16 function rrspacing_test2(x)
real*16 :: x
rrspacing_test2 = rrspacing(x)
-! CHECK: %[[a1:.*]] = fir.load %[[x]] : !fir.ref<f128>
+! CHECK: %[[x:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QFrrspacing_test2Ex"}
+! CHECK: %[[a1:.*]] = fir.load %[[x]]#0 : !fir.ref<f128>
! CHECK: %{{.*}} = fir.call @_FortranARRSpacing16(%[[a1]]) {{.*}}: (f128) -> f128
end function
diff --git a/flang/test/Lower/structure-constructors.f90 b/flang/test/Lower/structure-constructors.f90
index 5641a370e0ae4..987e36f9728f1 100644
--- a/flang/test/Lower/structure-constructors.f90
+++ b/flang/test/Lower/structure-constructors.f90
@@ -1,5 +1,5 @@
! Test lowering of structure constructors
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
module m_struct_ctor
implicit none
@@ -28,91 +28,84 @@ module m_struct_ctor
end type
contains
! CHECK-LABEL: func @_QMm_struct_ctorPtest_simple(
- ! CHECK-SAME: %[[x:.*]]: !fir.ref<f32>{{.*}})
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}})
subroutine test_simple(x)
real :: x
! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_simple{x:f32}>
- ! CHECK: %[[xcoor:.*]] = fir.coordinate_of %[[tmp]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_simple{x:f32}>>) -> !fir.ref<f32>
- ! CHECK: %[[val:.*]] = fir.load %[[x]] : !fir.ref<f32>
- ! CHECK: fir.store %[[val]] to %[[xcoor]] : !fir.ref<f32>
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_simpleEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: %[[val:.*]] = fir.load %[[xdecl]]#0 : !fir.ref<f32>
+ ! CHECK: hlfir.assign %[[val]] to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
call print_simple(t_simple(x=x))
end subroutine
! CHECK-LABEL: func @_QMm_struct_ctorPtest_char_scalar(
- ! CHECK-SAME: %[[x:.*]]: !fir.ref<f32>{{.*}})
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}})
subroutine test_char_scalar(x)
! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_char_scalar{x:f32,c:!fir.char<1,3>}>
- ! CHECK: %[[xcoor:.*]] = fir.coordinate_of %[[tmp]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_scalar{x:f32,c:!fir.char<1,3>}>>) -> !fir.ref<f32>
- ! CHECK: %[[val:.*]] = fir.load %[[x]] : !fir.ref<f32>
- ! CHECK: fir.store %[[val]] to %[[xcoor]] : !fir.ref<f32>
-
- ! CHECK: %[[ccoor:.*]] = fir.coordinate_of %[[tmp]], c : (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_scalar{x:f32,c:!fir.char<1,3>}>>) -> !fir.ref<!fir.char<1,3>>
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_char_scalarEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: %[[val:.*]] = fir.load %[[xdecl]]#0 : !fir.ref<f32>
+ ! CHECK: hlfir.assign %[[val]] to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
+ ! CHECK: %[[ccoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"c"}{{.*}} typeparams %{{.*}} : (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_scalar{x:f32,c:!fir.char<1,3>}>>, index) -> !fir.ref<!fir.char<1,3>>
! CHECK: %[[cst:.*]] = fir.address_of(@_QQ{{.*}}) : !fir.ref<!fir.char<1,3>>
- ! CHECK-DAG: %[[ccast:.*]] = fir.convert %[[ccoor]] : (!fir.ref<!fir.char<1,3>>) -> !llvm.ptr
- ! CHECK-DAG: %[[cstcast:.*]] = fir.convert %[[cst]] : (!fir.ref<!fir.char<1,3>>) -> !llvm.ptr
- ! CHECK: "llvm.intr.memmove"(%[[ccast]], %[[cstcast]], %{{.*}}) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
+ ! CHECK: %[[cstdecl:.*]]:2 = hlfir.declare %[[cst]] typeparams %{{.*}} {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQ{{.*}}"} : (!fir.ref<!fir.char<1,3>>, index) -> (!fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>)
+ ! CHECK: hlfir.assign %[[cstdecl]]#0 to %[[ccoor]] temporary_lhs : !fir.ref<!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>
real :: x
call print_char_scalar(t_char_scalar(x=x, c="abc"))
end subroutine
! CHECK-LABEL: func @_QMm_struct_ctorPtest_simple_array(
- ! CHECK-SAME: %[[x:.*]]: !fir.ref<f32>{{.*}}, %[[j:.*]]: !fir.ref<!fir.array<5xi32>>{{.*}})
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.array<5xi32>>{{.*}})
subroutine test_simple_array(x, j)
real :: x
integer :: j(5)
call print_simple_array(t_array(x=x, i=2*j))
! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>
- ! CHECK: %[[xcoor:.*]] = fir.coordinate_of %[[tmp]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<f32>
- ! CHECK: %[[val:.*]] = fir.load %[[x]] : !fir.ref<f32>
- ! CHECK: fir.store %[[val]] to %[[xcoor]] : !fir.ref<f32>
-
- ! CHECK: %[[icoor:.*]] = fir.coordinate_of %[[tmp]], i : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<!fir.array<5xi32>>
- ! CHECK: %[[iload:.*]] = fir.array_load %[[icoor]](%{{.*}}) : (!fir.ref<!fir.array<5xi32>>, !fir.shape<1>) -> !fir.array<5xi32>
- ! CHECK: %[[jload:.*]] = fir.array_load %[[j]](%{{.*}}) : (!fir.ref<!fir.array<5xi32>>, !fir.shape<1>) -> !fir.array<5xi32>
- ! CHECK: %[[loop:.*]] = fir.do_loop %[[idx:.*]] = %c0{{.*}} to %{{.*}} step %c1{{.*}} iter_args(%[[res:.*]] = %[[iload]]) -> (!fir.array<5xi32>) {
- ! CHECK: %[[jval:.*]] = fir.array_fetch %[[jload]], %[[idx]] : (!fir.array<5xi32>, index) -> i32
- ! CHECK: %[[ival:.*]] = arith.muli %c2{{.*}}, %[[jval]] : i32
- ! CHECK: %[[iupdate:.*]] = fir.array_update %[[res]], %[[ival]], %[[idx]] : (!fir.array<5xi32>, i32, index) -> !fir.array<5xi32>
- ! CHECK: fir.result %[[iupdate]] : !fir.array<5xi32>
- ! CHECK: fir.array_merge_store %[[iload]], %[[loop]] to %[[icoor]] : !fir.array<5xi32>, !fir.array<5xi32>, !fir.ref<!fir.array<5xi32>>
-
+ ! CHECK: %[[shape:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
+ ! CHECK: %[[jdecl:.*]]:2 = hlfir.declare %[[arg1]](%[[shape]]){{.*}}{uniq_name = "_QMm_struct_ctorFtest_simple_arrayEj"}
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_simple_arrayEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: %[[xval:.*]] = fir.load %[[xdecl]]#0 : !fir.ref<f32>
+ ! CHECK: hlfir.assign %[[xval]] to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
+ ! CHECK: %[[icoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"i"}
+ ! CHECK: %[[c2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[elem:.*]] = hlfir.elemental %[[shape]] unordered : (!fir.shape<1>) -> !hlfir.expr<5xi32> {
+ ! CHECK: %[[idx:.*]] = hlfir.designate %[[jdecl]]#0 (%{{.*}}) : (!fir.ref<!fir.array<5xi32>>, index) -> !fir.ref<i32>
+ ! CHECK: %[[jval:.*]] = fir.load %[[idx]] : !fir.ref<i32>
+ ! CHECK: %[[mul:.*]] = arith.muli %[[c2]], %[[jval]] : i32
+ ! CHECK: hlfir.yield_element %[[mul]] : i32
+ ! CHECK: }
+ ! CHECK: hlfir.assign %[[elem]] to %[[icoor]] temporary_lhs : !hlfir.expr<5xi32>, !fir.ref<!fir.array<5xi32>>
+ ! CHECK: hlfir.destroy %[[elem]] : !hlfir.expr<5xi32>
end subroutine
! CHECK-LABEL: func @_QMm_struct_ctorPtest_char_array(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<f32>{{.*}}, %[[VAL_1:.*]]: !fir.boxchar<1>{{.*}}) {
+! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}}, %[[arg1:.*]]: !fir.boxchar<1>{{.*}}) {
subroutine test_char_array(x, c1)
- ! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_char_array{x:f32,c:!fir.array<5x!fir.char<1,3>>}>
- ! CHECK: %[[VAL_4:.*]]:2 = fir.unboxchar %[[VAL_1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
- ! CHECK: %[[VAL_5:.*]] = fir.convert %[[VAL_4]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<5x!fir.char<1,3>>>
- ! CHECK: %[[VAL_6:.*]] = arith.constant 5 : index
- ! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_3]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_array{x:f32,c:!fir.array<5x!fir.char<1,3>>}>>) -> !fir.ref<f32>
- ! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_0]] : !fir.ref<f32>
- ! CHECK: fir.store %[[VAL_9]] to %[[VAL_8]] : !fir.ref<f32>
- ! CHECK: %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_3]], c : (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_array{x:f32,c:!fir.array<5x!fir.char<1,3>>}>>) -> !fir.ref<!fir.array<5x!fir.char<1,3>>>
- ! CHECK: %[[VAL_12:.*]] = arith.constant 5 : index
- ! CHECK: %[[VAL_13:.*]] = fir.shape %[[VAL_12]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_14:.*]] = fir.array_load %[[VAL_11]](%[[VAL_13]]) : (!fir.ref<!fir.array<5x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.array<5x!fir.char<1,3>>
- ! CHECK: %[[VAL_15:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_5]](%[[VAL_15]]) : (!fir.ref<!fir.array<5x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.array<5x!fir.char<1,3>>
- ! CHECK: %[[char_temp:.*]] = fir.alloca !fir.char<1,3> {bindc_name = ".chrtmp"}
- ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : index
- ! CHECK: %[[VAL_18:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_19:.*]] = arith.subi %[[VAL_12]], %[[VAL_17]] : index
- ! CHECK: %[[VAL_20:.*]] = fir.do_loop %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_19]] step %[[VAL_17]] unordered iter_args(%[[VAL_22:.*]] = %[[VAL_14]]) -> (!fir.array<5x!fir.char<1,3>>) {
- ! CHECK: %[[VAL_23:.*]] = fir.array_access %[[VAL_16]], %[[VAL_21]] : (!fir.array<5x!fir.char<1,3>>, index) -> !fir.ref<!fir.char<1,3>>
- ! CHECK: %[[VAL_24:.*]] = fir.array_access %[[VAL_22]], %[[VAL_21]] : (!fir.array<5x!fir.char<1,3>>, index) -> !fir.ref<!fir.char<1,3>>
- ! CHECK: %[[VAL_25:.*]] = arith.constant 3 : index
- ! CHECK: %[[VAL_26:.*]] = arith.constant 1 : i64
- ! CHECK: %[[VAL_27:.*]] = fir.convert %[[VAL_25]] : (index) -> i64
- ! CHECK: %[[VAL_28:.*]] = arith.muli %[[VAL_26]], %[[VAL_27]] : i64
- ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_24]] : (!fir.ref<!fir.char<1,3>>) -> !llvm.ptr
- ! CHECK: %[[VAL_31:.*]] = fir.convert %[[char_temp]] : (!fir.ref<!fir.char<1,3>>) -> !llvm.ptr
- ! CHECK: "llvm.intr.memmove"(%[[VAL_30]], %[[VAL_31]], %[[VAL_28]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
- ! CHECK: %[[VAL_32:.*]] = fir.array_amend %[[VAL_22]], %[[VAL_24]] : (!fir.array<5x!fir.char<1,3>>, !fir.ref<!fir.char<1,3>>) -> !fir.array<5x!fir.char<1,3>>
- ! CHECK: fir.result %[[VAL_32]] : !fir.array<5x!fir.char<1,3>>
+ ! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_char_array{x:f32,c:!fir.array<5x!fir.char<1,3>>}>
+ ! CHECK: %[[unbox:.*]]:2 = fir.unboxchar %[[arg1]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+ ! CHECK: %[[c1ref:.*]] = fir.convert %[[unbox]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<5x!fir.char<1,3>>>
+ ! CHECK: %[[c1decl:.*]]:2 = hlfir.declare %[[c1ref]](%{{.*}}) typeparams %{{.*}}{{.*}}{uniq_name = "_QMm_struct_ctorFtest_char_arrayEc1"}
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_char_arrayEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: hlfir.assign %{{.*}} to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
+ ! CHECK: %[[ccoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"c"}
+ ! CHECK: %[[elem:.*]] = hlfir.elemental %{{.*}} typeparams %{{.*}} unordered : (!fir.shape<1>, i64) -> !hlfir.expr<5x!fir.char<1,?>> {
+ ! CHECK: %[[carg:.*]] = hlfir.designate %[[c1decl]]#0 (%{{.*}}) typeparams %{{.*}} : (!fir.ref<!fir.array<5x!fir.char<1,3>>>, index, index) -> !fir.ref<!fir.char<1,3>>
+ ! CHECK: %[[setlen:.*]] = hlfir.set_length %[[carg]] len %{{.*}} : (!fir.ref<!fir.char<1,3>>, i64) -> !hlfir.expr<!fir.char<1,3>>
+ ! CHECK: hlfir.yield_element %[[setlen]] : !hlfir.expr<!fir.char<1,3>>
! CHECK: }
- ! CHECK: fir.array_merge_store %[[VAL_14]], %[[VAL_33:.*]] to %[[VAL_11]] : !fir.array<5x!fir.char<1,3>>, !fir.array<5x!fir.char<1,3>>, !fir.ref<!fir.array<5x!fir.char<1,3>>>
- ! CHECK: fir.call @_QMm_struct_ctorPprint_char_array(%[[VAL_3]]) {{.*}}: (!fir.ref<!fir.type<_QMm_struct_ctorTt_char_array{x:f32,c:!fir.array<5x!fir.char<1,3>>}>>) -> ()
+ ! CHECK: hlfir.assign %[[elem]] to %[[ccoor]] temporary_lhs : !hlfir.expr<5x!fir.char<1,?>>, !fir.ref<!fir.array<5x!fir.char<1,3>>>
+ ! CHECK: fir.call @_QMm_struct_ctorPprint_char_array(%[[tmpdecl]]#0)
real :: x
character(3) :: c1(5)
@@ -122,29 +115,19 @@ subroutine test_char_array(x, c1)
end subroutine
! CHECK-LABEL: func @_QMm_struct_ctorPtest_ptr(
- ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<f32>{{.*}}, %[[VAL_1:.*]]: !fir.box<!fir.array<?x?xi32>> {{{.*}}, fir.target}) {
- ! CHECK: %[[VAL_3:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_ptr{x:f32,p:!fir.box<!fir.ptr<!fir.array<?x?xi32>>>}>
- ! CHECK: %[[VAL_5:.*]] = fir.coordinate_of %[[VAL_3]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_ptr{x:f32,p:!fir.box<!fir.ptr<!fir.array<?x?xi32>>>}>>) -> !fir.ref<f32>
- ! CHECK: %[[VAL_6:.*]] = fir.load %[[VAL_0]] : !fir.ref<f32>
- ! CHECK: fir.store %[[VAL_6]] to %[[VAL_5]] : !fir.ref<f32>
- ! CHECK: %[[VAL_8:.*]] = fir.coordinate_of %[[VAL_3]], p : (!fir.ref<!fir.type<_QMm_struct_ctorTt_ptr{x:f32,p:!fir.box<!fir.ptr<!fir.array<?x?xi32>>>}>>) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xi32>>>>
- ! CHECK: %[[VAL_9:.*]] = arith.constant 1 : i64
- ! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_9]] : (i64) -> index
- ! CHECK: %[[VAL_11:.*]] = arith.constant 2 : i64
- ! CHECK: %[[VAL_12:.*]] = fir.convert %[[VAL_11]] : (i64) -> index
- ! CHECK: %[[VAL_13:.*]] = arith.constant 4 : i64
- ! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i64) -> index
- ! CHECK: %[[VAL_15:.*]] = arith.constant 1 : i64
- ! CHECK: %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i64) -> index
- ! CHECK: %[[VAL_17:.*]] = arith.constant 1 : i64
- ! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (i64) -> index
- ! CHECK: %[[VAL_19:.*]] = arith.constant 3 : i64
- ! CHECK: %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i64) -> index
- ! CHECK: %[[VAL_21:.*]] = fir.slice %[[VAL_10]], %[[VAL_14]], %[[VAL_12]], %[[VAL_16]], %[[VAL_20]], %[[VAL_18]] : (index, index, index, index, index, index) -> !fir.slice<2>
- ! CHECK: %[[VAL_22:.*]] = fir.rebox %[[VAL_1]] {{\[}}%[[VAL_21]]] : (!fir.box<!fir.array<?x?xi32>>, !fir.slice<2>) -> !fir.box<!fir.array<2x3xi32>>
- ! CHECK: %[[VAL_23:.*]] = fir.rebox %[[VAL_22]] : (!fir.box<!fir.array<2x3xi32>>) -> !fir.box<!fir.ptr<!fir.array<?x?xi32>>>
- ! CHECK: fir.store %[[VAL_23]] to %[[VAL_8]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xi32>>>>
- ! CHECK: fir.call @_QMm_struct_ctorPprint_ptr(%[[VAL_3]]) {{.*}}: (!fir.ref<!fir.type<_QMm_struct_ctorTt_ptr{x:f32,p:!fir.box<!fir.ptr<!fir.array<?x?xi32>>>}>>) -> ()
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x?xi32>> {{{.*}}, fir.target}) {
+ ! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_ptr{x:f32,p:!fir.box<!fir.ptr<!fir.array<?x?xi32>>>}>
+ ! CHECK: %[[adecl:.*]]:2 = hlfir.declare %[[arg1]]{{.*}}{fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QMm_struct_ctorFtest_ptrEa"}
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_ptrEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: hlfir.assign %{{.*}} to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
+ ! CHECK: %[[pcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"p"}{{.*}}{fortran_attrs = #fir.var_attrs<pointer>}
+ ! CHECK: %[[slice:.*]] = hlfir.designate %[[adecl]]#0 (%{{.*}}:%{{.*}}:%{{.*}}, %{{.*}}:%{{.*}}:%{{.*}}) shape %{{.*}} : (!fir.box<!fir.array<?x?xi32>>, index, index, index, index, index, index, !fir.shape<2>) -> !fir.box<!fir.array<2x3xi32>>
+ ! CHECK: %[[rebox:.*]] = fir.rebox %[[slice]] : (!fir.box<!fir.array<2x3xi32>>) -> !fir.box<!fir.ptr<!fir.array<?x?xi32>>>
+ ! CHECK: fir.store %[[rebox]] to %[[pcoor]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?xi32>>>>
+ ! CHECK: fir.call @_QMm_struct_ctorPprint_ptr(%[[tmpdecl]]#0)
! CHECK: return
! CHECK: }
@@ -155,30 +138,20 @@ subroutine test_ptr(x, a)
end subroutine
! CHECK-LABEL: func @_QMm_struct_ctorPtest_nested(
- ! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<f32>{{.*}}, %[[VAL_1:.*]]: !fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>
+ ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<f32>{{.*}}, %[[arg1:.*]]: !fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>
subroutine test_nested(x, d)
real :: x
type(t_array) :: d
- ! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_nested{x:f32,dt:!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>}>
- ! CHECK: %[[VAL_4:.*]] = fir.coordinate_of %[[VAL_2]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_nested{x:f32,dt:!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>}>>) -> !fir.ref<f32>
- ! CHECK: %[[VAL_5:.*]] = fir.load %[[VAL_0]] : !fir.ref<f32>
- ! CHECK: fir.store %[[VAL_5]] to %[[VAL_4]] : !fir.ref<f32>
- ! CHECK: %[[VAL_7:.*]] = fir.coordinate_of %[[VAL_2]], dt : (!fir.ref<!fir.type<_QMm_struct_ctorTt_nested{x:f32,dt:!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>}>>) -> !fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>
- ! CHECK: %[[VAL_9:.*]] = fir.coordinate_of %[[VAL_1]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<f32>
- ! CHECK: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_7]], x : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<f32>
- ! CHECK: %[[VAL_11:.*]] = fir.load %[[VAL_9]] : !fir.ref<f32>
- ! CHECK: fir.store %[[VAL_11]] to %[[VAL_10]] : !fir.ref<f32>
- ! CHECK: %[[VAL_13:.*]] = fir.coordinate_of %[[VAL_1]], i : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<!fir.array<5xi32>>
- ! CHECK: %[[VAL_14:.*]] = fir.coordinate_of %[[VAL_7]], i : (!fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>) -> !fir.ref<!fir.array<5xi32>>
- ! CHECK: %[[VAL_15:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_16:.*]] = arith.constant 1 : index
- ! CHECK: %[[VAL_17:.*]] = arith.constant 4 : index
- ! CHECK: fir.do_loop %[[VAL_18:.*]] = %[[VAL_15]] to %[[VAL_17]] step %[[VAL_16]] {
- ! CHECK: %[[VAL_19:.*]] = fir.coordinate_of %[[VAL_14]], %[[VAL_18]] : (!fir.ref<!fir.array<5xi32>>, index) -> !fir.ref<i32>
- ! CHECK: %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_13]], %[[VAL_18]] : (!fir.ref<!fir.array<5xi32>>, index) -> !fir.ref<i32>
- ! CHECK: %[[VAL_21:.*]] = fir.load %[[VAL_20]] : !fir.ref<i32>
- ! CHECK: fir.store %[[VAL_21]] to %[[VAL_19]] : !fir.ref<i32>
- ! CHECK: }
+ ! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QMm_struct_ctorTt_nested{x:f32,dt:!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>}>
+ ! CHECK: %[[ddecl:.*]]:2 = hlfir.declare %[[arg1]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_nestedEd"}
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMm_struct_ctorFtest_nestedEx"}
+ ! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+ ! CHECK: fir.call @_FortranAInitialize(
+ ! CHECK: %[[xcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"x"}
+ ! CHECK: %[[xval:.*]] = fir.load %[[xdecl]]#0 : !fir.ref<f32>
+ ! CHECK: hlfir.assign %[[xval]] to %[[xcoor]] temporary_lhs : f32, !fir.ref<f32>
+ ! CHECK: %[[dtcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"dt"}
+ ! CHECK: hlfir.assign %[[ddecl]]#0 to %[[dtcoor]] temporary_lhs : !fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>, !fir.ref<!fir.type<_QMm_struct_ctorTt_array{x:f32,i:!fir.array<5xi32>}>>
call print_nested(t_nested(x=x, dt=d))
end subroutine
@@ -220,48 +193,12 @@ subroutine print_nested(t)
end
! CHECK-LABEL: func.func @_QPtest_parent_component1() {
-! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>
-! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.type<_QFtest_parent_component1Tmid{x:i32,y:!fir.array<2xi32>,mask:!fir.logical<4>}>
-! CHECK: %[[VAL_15:.*]] = fir.coordinate_of %[[VAL_0]], x : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<i32>
-! CHECK: %[[VAL_16:.*]] = arith.constant 1 : i32
-! CHECK: fir.store %[[VAL_16]] to %[[VAL_15]] : !fir.ref<i32>
-! CHECK: %[[VAL_18:.*]] = fir.coordinate_of %[[VAL_0]], y : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<!fir.array<2xi32>>
-! CHECK: %[[VAL_19:.*]] = arith.constant 2 : index
-! CHECK: %[[VAL_20:.*]] = fir.shape %[[VAL_19]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_21:.*]] = fir.array_load %[[VAL_18]](%[[VAL_20]]) : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> !fir.array<2xi32>
-! CHECK: %[[VAL_23:.*]] = arith.constant 2 : index
-! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_23]] : (index) -> !fir.shape<1>
-! CHECK: %[[VAL_25:.*]] = fir.array_load %[[VAL_22:.*]](%[[VAL_24]]) : (!fir.ref<!fir.array<2xi32>>, !fir.shape<1>) -> !fir.array<2xi32>
-! CHECK: %[[VAL_26:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_27:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_28:.*]] = arith.subi %[[VAL_19]], %[[VAL_26]] : index
-! CHECK: %[[VAL_29:.*]] = fir.do_loop %[[VAL_30:.*]] = %[[VAL_27]] to %[[VAL_28]] step %[[VAL_26]] unordered iter_args(%[[VAL_31:.*]] = %[[VAL_21]]) -> (!fir.array<2xi32>) {
-! CHECK: %[[VAL_32:.*]] = fir.array_fetch %[[VAL_25]], %[[VAL_30]] : (!fir.array<2xi32>, index) -> i32
-! CHECK: %[[VAL_33:.*]] = fir.array_update %[[VAL_31]], %[[VAL_32]], %[[VAL_30]] : (!fir.array<2xi32>, i32, index) -> !fir.array<2xi32>
-! CHECK: fir.result %[[VAL_33]] : !fir.array<2xi32>
-! CHECK: }
-! CHECK: fir.array_merge_store %[[VAL_21]], %[[VAL_34:.*]] to %[[VAL_18]] : !fir.array<2xi32>, !fir.array<2xi32>, !fir.ref<!fir.array<2xi32>>
-! CHECK: %[[VAL_35:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.type<_QFtest_parent_component1Tmid{x:i32,y:!fir.array<2xi32>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>
-! CHECK: %[[VAL_37:.*]] = fir.coordinate_of %[[VAL_0]], x : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<i32>
-! CHECK: %[[VAL_39:.*]] = fir.coordinate_of %[[VAL_35]], x : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<i32>
-! CHECK: %[[VAL_40:.*]] = fir.load %[[VAL_37]] : !fir.ref<i32>
-! CHECK: fir.store %[[VAL_40]] to %[[VAL_39]] : !fir.ref<i32>
-! CHECK: %[[VAL_42:.*]] = fir.coordinate_of %[[VAL_0]], y : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<!fir.array<2xi32>>
-! CHECK: %[[VAL_44:.*]] = fir.coordinate_of %[[VAL_35]], y : (!fir.ref<!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>>) -> !fir.ref<!fir.array<2xi32>>
-! CHECK: %[[VAL_45:.*]] = arith.constant 0 : index
-! CHECK: %[[VAL_46:.*]] = arith.constant 1 : index
-! CHECK: %[[VAL_47:.*]] = arith.constant 1 : index
-! CHECK: fir.do_loop %[[VAL_48:.*]] = %[[VAL_45]] to %[[VAL_47]] step %[[VAL_46]] {
-! CHECK: %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_48]] : (!fir.ref<!fir.array<2xi32>>, index) -> !fir.ref<i32>
-! CHECK: %[[VAL_50:.*]] = fir.coordinate_of %[[VAL_42]], %[[VAL_48]] : (!fir.ref<!fir.array<2xi32>>, index) -> !fir.ref<i32>
-! CHECK: %[[VAL_51:.*]] = fir.load %[[VAL_50]] : !fir.ref<i32>
-! CHECK: fir.store %[[VAL_51]] to %[[VAL_49]] : !fir.ref<i32>
-! CHECK: }
-! CHECK: %[[VAL_53:.*]] = fir.coordinate_of %[[VAL_1]], mask : (!fir.ref<!fir.type<_QFtest_parent_component1Tmid{x:i32,y:!fir.array<2xi32>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_54:.*]] = arith.constant true
-! CHECK: %[[VAL_55:.*]] = fir.convert %[[VAL_54]] : (i1) -> !fir.logical<4>
-! CHECK: fir.store %[[VAL_55]] to %[[VAL_53]] : !fir.ref<!fir.logical<4>>
-! CHECK: fir.call @_QPprint_parent_component1(%[[VAL_1]]) {{.*}}: (!fir.ref<!fir.type<_QFtest_parent_component1Tmid{x:i32,y:!fir.array<2xi32>,mask:!fir.logical<4>}>>) -> ()
+! CHECK: %[[ro:.*]] = fir.address_of(@_QQro._QFtest_parent_component1Tmid.{{[0-9]+}}) : !fir.ref<!fir.type<_QFtest_parent_component1Tmid{base:!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>,mask:!fir.logical<4>}>>
+! CHECK: %[[rodecl:.*]]:2 = hlfir.declare %[[ro]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QQro._QFtest_parent_component1Tmid.{{[0-9]+}}"}
+! CHECK: %[[expr:.*]] = hlfir.as_expr %[[rodecl]]#0 : (!fir.ref<!fir.type<_QFtest_parent_component1Tmid{base:!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>,mask:!fir.logical<4>}>>) -> !hlfir.expr<!fir.type<_QFtest_parent_component1Tmid{base:!fir.type<_QFtest_parent_component1Tbase{x:i32,y:!fir.array<2xi32>}>,mask:!fir.logical<4>}>>
+! CHECK: %[[assoc:.*]]:3 = hlfir.associate %[[expr]] {adapt.valuebyref}
+! CHECK: fir.call @_QPprint_parent_component1(%[[assoc]]#0)
+! CHECK: hlfir.end_associate %[[assoc]]#1, %[[assoc]]#2
! CHECK: return
! CHECK: }
@@ -277,23 +214,18 @@ subroutine test_parent_component1()
end
! CHECK-LABEL: func.func @_QPtest_parent_component2() {
-! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.type<_QFtest_parent_component2Tmid{z:!fir.char<1,5>,mask:!fir.logical<4>}>
-! CHECK: %[[VAL_1:.*]] = fir.address_of(@_QFtest_parent_component2Epv) : !fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>
-! CHECK: %[[VAL_8:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.type<_QFtest_parent_component2Tmid{z:!fir.char<1,5>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>
-! CHECK: %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_1]], z : (!fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>) -> !fir.ref<!fir.char<1,5>>
-! CHECK: %[[VAL_12:.*]] = fir.coordinate_of %[[VAL_8]], z : (!fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>) -> !fir.ref<!fir.char<1,5>>
-! CHECK: %[[VAL_13:.*]] = arith.constant 5 : index
-! CHECK: %[[VAL_14:.*]] = arith.constant 1 : i64
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_13]] : (index) -> i64
-! CHECK: %[[VAL_16:.*]] = arith.muli %[[VAL_14]], %[[VAL_15]] : i64
-! CHECK: %[[VAL_18:.*]] = fir.convert %[[VAL_12]] : (!fir.ref<!fir.char<1,5>>) -> !llvm.ptr
-! CHECK: %[[VAL_19:.*]] = fir.convert %[[VAL_10]] : (!fir.ref<!fir.char<1,5>>) -> !llvm.ptr
-! CHECK: "llvm.intr.memmove"(%[[VAL_18]], %[[VAL_19]], %[[VAL_16]]) <{isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i64) -> ()
-! CHECK: %[[VAL_21:.*]] = fir.coordinate_of %[[VAL_0]], mask : (!fir.ref<!fir.type<_QFtest_parent_component2Tmid{z:!fir.char<1,5>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_22:.*]] = arith.constant true
-! CHECK: %[[VAL_23:.*]] = fir.convert %[[VAL_22]] : (i1) -> !fir.logical<4>
-! CHECK: fir.store %[[VAL_23]] to %[[VAL_21]] : !fir.ref<!fir.logical<4>>
-! CHECK: fir.call @_QPprint_parent_component2(%[[VAL_0]]) {{.*}}: (!fir.ref<!fir.type<_QFtest_parent_component2Tmid{z:!fir.char<1,5>,mask:!fir.logical<4>}>>) -> ()
+! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QFtest_parent_component2Tmid{base:!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>,mask:!fir.logical<4>}>
+! CHECK: %[[pv:.*]] = fir.address_of(@_QFtest_parent_component2Epv) : !fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>
+! CHECK: %[[pvdecl:.*]]:2 = hlfir.declare %[[pv]] {uniq_name = "_QFtest_parent_component2Epv"}
+! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+! CHECK: fir.call @_FortranAInitialize(
+! CHECK: %[[basecoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"base"}
+! CHECK: hlfir.assign %[[pvdecl]]#0 to %[[basecoor]] temporary_lhs : !fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>, !fir.ref<!fir.type<_QFtest_parent_component2Tbase{z:!fir.char<1,5>}>>
+! CHECK: %[[maskcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"mask"}
+! CHECK: %[[t:.*]] = arith.constant true
+! CHECK: %[[lt:.*]] = fir.convert %[[t]] : (i1) -> !fir.logical<4>
+! CHECK: hlfir.assign %[[lt]] to %[[maskcoor]] temporary_lhs : !fir.logical<4>, !fir.ref<!fir.logical<4>>
+! CHECK: fir.call @_QPprint_parent_component2(%[[tmpdecl]]#0)
! CHECK: return
! CHECK: }
@@ -310,21 +242,20 @@ subroutine test_parent_component2()
end
! CHECK-LABEL: func.func @_QPtest_parent_component3(
-! CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>> {fir.bindc_name = "pp"}) {
-! CHECK: %[[VAL_1:.*]] = fir.alloca !fir.box<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>
-! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.type<_QFtest_parent_component3Tmid{m:!fir.array<2x!fir.char<1,5>>,mask:!fir.logical<4>}>
-! CHECK: %[[VAL_9:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>>
-! CHECK: %[[VAL_10:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.type<_QFtest_parent_component3Tmid{m:!fir.array<2x!fir.char<1,5>>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>
-! CHECK: %[[VAL_11:.*]] = fir.embox %[[VAL_10]] : (!fir.ref<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>) -> !fir.box<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>
-! CHECK: fir.store %[[VAL_11]] to %[[VAL_1]] : !fir.ref<!fir.box<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>
-! CHECK: %[[VAL_14:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.box<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>) -> !fir.ref<!fir.box<none>>
-! CHECK: %[[VAL_15:.*]] = fir.convert %[[VAL_9]] : (!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>) -> !fir.box<none>
-! CHECK: fir.call @_FortranAAssign(%[[VAL_14]], %[[VAL_15]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
-! CHECK: %[[VAL_19:.*]] = fir.coordinate_of %[[VAL_2]], mask : (!fir.ref<!fir.type<_QFtest_parent_component3Tmid{m:!fir.array<2x!fir.char<1,5>>,mask:!fir.logical<4>}>>) -> !fir.ref<!fir.logical<4>>
-! CHECK: %[[VAL_20:.*]] = arith.constant true
-! CHECK: %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i1) -> !fir.logical<4>
-! CHECK: fir.store %[[VAL_21]] to %[[VAL_19]] : !fir.ref<!fir.logical<4>>
-! CHECK: fir.call @_QPprint_parent_component3(%[[VAL_2]]) {{.*}}: (!fir.ref<!fir.type<_QFtest_parent_component3Tmid{m:!fir.array<2x!fir.char<1,5>>,mask:!fir.logical<4>}>>) -> ()
+! CHECK-SAME: %[[arg0:.*]]: !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>> {fir.bindc_name = "pp"}) {
+! CHECK: %[[tmp:.*]] = fir.alloca !fir.type<_QFtest_parent_component3Tmid{base:!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>,mask:!fir.logical<4>}>
+! CHECK: %[[ppdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QFtest_parent_component3Epp"}
+! CHECK: %[[tmpdecl:.*]]:2 = hlfir.declare %[[tmp]] {uniq_name = "ctor.temp"}
+! CHECK: fir.call @_FortranAInitialize(
+! CHECK: %[[basecoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"base"}
+! CHECK: %[[ppload:.*]] = fir.load %[[ppdecl]]#0 : !fir.ref<!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>>
+! CHECK: %[[ppaddr:.*]] = fir.box_addr %[[ppload]] : (!fir.box<!fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>>) -> !fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>
+! CHECK: hlfir.assign %[[ppaddr]] to %[[basecoor]] temporary_lhs : !fir.ptr<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>, !fir.ref<!fir.type<_QFtest_parent_component3Tbase{m:!fir.array<2x!fir.char<1,5>>}>>
+! CHECK: %[[maskcoor:.*]] = hlfir.designate %[[tmpdecl]]#0{"mask"}
+! CHECK: %[[t:.*]] = arith.constant true
+! CHECK: %[[lt:.*]] = fir.convert %[[t]] : (i1) -> !fir.logical<4>
+! CHECK: hlfir.assign %[[lt]] to %[[maskcoor]] temporary_lhs : !fir.logical<4>, !fir.ref<!fir.logical<4>>
+! CHECK: fir.call @_QPprint_parent_component3(%[[tmpdecl]]#0)
! CHECK: return
! CHECK: }
diff --git a/flang/test/Lower/transformational-intrinsics.f90 b/flang/test/Lower/transformational-intrinsics.f90
index 5e10f0f510720..d86507d7b2c1a 100644
--- a/flang/test/Lower/transformational-intrinsics.f90
+++ b/flang/test/Lower/transformational-intrinsics.f90
@@ -1,6 +1,6 @@
! Test how transformational intrinsic function references are lowered
-! RUN: bbc -emit-fir -hlfir=false %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-hlfir %s -o - | FileCheck %s
! The exact intrinsic being tested does not really matter, what is
! tested here is that transformational intrinsics are lowered correctly
@@ -21,19 +21,19 @@ subroutine takes_array_desc(l)
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
subroutine in_io(x)
logical(1) :: x(:, :)
- ! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
- ! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
- ! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()
- ! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
- ! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
- ! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
- ! CHECK: %[[io_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
- ! CHECK: %[[io_embox_cast:.*]] = fir.convert %[[io_embox]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.box<none>
- ! CHECK: fir.call @_Fortran{{.*}}ioOutputDescriptor({{.*}}, %[[io_embox_cast]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMtest2Fin_ioEx"}
+ ! CHECK: %[[c1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[all:.*]] = hlfir.all %[[xdecl]]#0 dim %[[c1]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>, i32) -> !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: %[[shape:.*]] = hlfir.shape_of %[[all]] : (!hlfir.expr<?x!fir.logical<1>>) -> !fir.shape<1>
+ ! CHECK: %[[assoc:.*]]:3 = hlfir.associate %[[all]](%[[shape]]) {adapt.valuebyref} : (!hlfir.expr<?x!fir.logical<1>>, !fir.shape<1>) -> (!fir.box<!fir.array<?x!fir.logical<1>>>, !fir.ref<!fir.array<?x!fir.logical<1>>>, i1)
+ ! CHECK: %[[ext:.*]] = hlfir.get_extent %[[shape]] {dim = 0 : index} : (!fir.shape<1>) -> index
+ ! CHECK: %[[s2:.*]] = fir.shape %[[ext]] : (index) -> !fir.shape<1>
+ ! CHECK: %[[box:.*]] = fir.embox %[[assoc]]#1(%[[s2]]) : (!fir.ref<!fir.array<?x!fir.logical<1>>>, !fir.shape<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
+ ! CHECK: %[[boxnone:.*]] = fir.convert %[[box]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.box<none>
+ ! CHECK: fir.call @_FortranAioOutputDescriptor({{.*}}, %[[boxnone]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
+ ! CHECK: hlfir.end_associate %[[assoc]]#1, %[[assoc]]#2 : !fir.ref<!fir.array<?x!fir.logical<1>>>, i1
+ ! CHECK: hlfir.destroy %[[all]] : !hlfir.expr<?x!fir.logical<1>>
print *, all(x, 1)
- ! CHECK: fir.freemem %[[res_addr]] : !fir.heap<!fir.array<?x!fir.logical<1>>>
end subroutine
! CHECK-LABEL: func @_QMtest2Pin_call(
@@ -41,180 +41,90 @@ subroutine in_io(x)
subroutine in_call(x)
implicit none
logical(1) :: x(:, :)
- ! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
- ! CHECK-DAG: %[[res_arg:.*]] = fir.convert %[[res_desc]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[x_arg:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>) -> !fir.box<none>
- ! CHECK: fir.call @_Fortran{{.*}}AllDim(%[[res_arg]], %[[x_arg]], {{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()
- ! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
- ! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
- ! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
- ! CHECK: %[[call_embox:.*]] = fir.embox %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.box<!fir.array<?x!fir.logical<1>>>
- ! CHECK: fir.call @_QPtakes_array_desc(%[[call_embox]]) {{.*}}: (!fir.box<!fir.array<?x!fir.logical<1>>>) -> ()
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMtest2Fin_callEx"}
+ ! CHECK: %[[c1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[all:.*]] = hlfir.all %[[xdecl]]#0 dim %[[c1]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>, i32) -> !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: %[[shape:.*]] = hlfir.shape_of %[[all]] : (!hlfir.expr<?x!fir.logical<1>>) -> !fir.shape<1>
+ ! CHECK: %[[assoc:.*]]:3 = hlfir.associate %[[all]](%[[shape]]) {adapt.valuebyref} : (!hlfir.expr<?x!fir.logical<1>>, !fir.shape<1>) -> (!fir.box<!fir.array<?x!fir.logical<1>>>, !fir.ref<!fir.array<?x!fir.logical<1>>>, i1)
+ ! CHECK: fir.call @_QPtakes_array_desc(%[[assoc]]#0) {{.*}}: (!fir.box<!fir.array<?x!fir.logical<1>>>) -> ()
+ ! CHECK: hlfir.end_associate %[[assoc]]#1, %[[assoc]]#2 : !fir.ref<!fir.array<?x!fir.logical<1>>>, i1
+ ! CHECK: hlfir.destroy %[[all]] : !hlfir.expr<?x!fir.logical<1>>
call takes_array_desc(all(x, 1))
- ! CHECK: fir.freemem %[[res_addr]] : !fir.heap<!fir.array<?x!fir.logical<1>>>
end subroutine
! CHECK-LABEL: func @_QMtest2Pin_implicit_call(
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}) {
subroutine in_implicit_call(x)
logical(1) :: x(:, :)
- ! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
- ! CHECK: fir.call @_Fortran{{.*}}AllDim
- ! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
- ! CHECK: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
- ! CHECK: %[[res_addr_cast:.*]] = fir.convert %[[res_addr]] : (!fir.heap<!fir.array<?x!fir.logical<1>>>) -> !fir.ref<!fir.array<?x!fir.logical<1>>>
- ! CHECK: fir.call @_QPtakes_implicit_array(%[[res_addr_cast]]) {{.*}}: (!fir.ref<!fir.array<?x!fir.logical<1>>>) -> ()
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMtest2Fin_implicit_callEx"}
+ ! CHECK: %[[c1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[all:.*]] = hlfir.all %[[xdecl]]#0 dim %[[c1]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>, i32) -> !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: %[[shape:.*]] = hlfir.shape_of %[[all]] : (!hlfir.expr<?x!fir.logical<1>>) -> !fir.shape<1>
+ ! CHECK: %[[assoc:.*]]:3 = hlfir.associate %[[all]](%[[shape]]) {adapt.valuebyref} : (!hlfir.expr<?x!fir.logical<1>>, !fir.shape<1>) -> (!fir.box<!fir.array<?x!fir.logical<1>>>, !fir.ref<!fir.array<?x!fir.logical<1>>>, i1)
+ ! CHECK: fir.call @_QPtakes_implicit_array(%[[assoc]]#1) {{.*}}: (!fir.ref<!fir.array<?x!fir.logical<1>>>) -> ()
+ ! CHECK: hlfir.end_associate %[[assoc]]#1, %[[assoc]]#2 : !fir.ref<!fir.array<?x!fir.logical<1>>>, i1
+ ! CHECK: hlfir.destroy %[[all]] : !hlfir.expr<?x!fir.logical<1>>
call takes_implicit_array(all(x, 1))
- ! CHECK: fir.freemem %[[res_addr]] : !fir.heap<!fir.array<?x!fir.logical<1>>>
end subroutine
! CHECK-LABEL: func @_QMtest2Pin_assignment(
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
subroutine in_assignment(x, y)
logical(1) :: x(:, :), y(:)
- ! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
- ! CHECK: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
- ! CHECK: fir.call @_Fortran{{.*}}AllDim
-
- ! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
- ! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
- ! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
- ! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
-
- ! CHECK: %[[assign:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
- ! CHECK: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
- ! CHECK: fir.array_update %{{.*}} %[[res_elt]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
- ! CHECK: }
- ! CHECK: fir.array_merge_store %[[y_load]], %[[assign]] to %[[arg1]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMtest2Fin_assignmentEx"}
+ ! CHECK: %[[ydecl:.*]]:2 = hlfir.declare %[[arg1]]{{.*}}{uniq_name = "_QMtest2Fin_assignmentEy"}
+ ! CHECK: %[[c1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[all:.*]] = hlfir.all %[[xdecl]]#0 dim %[[c1]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>, i32) -> !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: hlfir.assign %[[all]] to %[[ydecl]]#0 : !hlfir.expr<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
+ ! CHECK: hlfir.destroy %[[all]] : !hlfir.expr<?x!fir.logical<1>>
y = all(x, 1)
- ! CHECK: fir.freemem %[[res_addr]] : !fir.heap<!fir.array<?x!fir.logical<1>>>
end subroutine
! CHECK-LABEL: func @_QMtest2Pin_elem_expr(
! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?x?x!fir.logical<1>>>{{.*}}, %[[arg1:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}}, %[[arg2:.*]]: !fir.box<!fir.array<?x!fir.logical<1>>>{{.*}})
subroutine in_elem_expr(x, y, z)
logical(1) :: x(:, :), y(:), z(:)
- ! CHECK: %[[res_desc:.]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>
- ! CHECK-DAG: %[[y_load:.*]] = fir.array_load %[[arg1]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
- ! CHECK-DAG: %[[z_load:.*]] = fir.array_load %[[arg2]] : (!fir.box<!fir.array<?x!fir.logical<1>>>) -> !fir.array<?x!fir.logical<1>>
- ! CHECK: fir.call @_Fortran{{.*}}AllDim
-
- ! CHECK: %[[res_desc_load:.*]] = fir.load %[[res_desc]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>>
- ! CHECK-DAG: %[[dims:.*]]:3 = fir.box_dims %[[res_desc_load]], %c0{{.*}} : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>, index) -> (index, index, index)
- ! CHECK-DAG: %[[res_addr:.*]] = fir.box_addr %[[res_desc_load]] : (!fir.box<!fir.heap<!fir.array<?x!fir.logical<1>>>>) -> !fir.heap<!fir.array<?x!fir.logical<1>>>
- ! CHECK-DAG: %[[res_shape:.*]] = fir.shape_shift %[[dims]]#0, %[[dims]]#1 : (index, index) -> !fir.shapeshift<1>
- ! CHECK: %[[res_load:.*]] = fir.array_load %[[res_addr]](%[[res_shape]]) : (!fir.heap<!fir.array<?x!fir.logical<1>>>, !fir.shapeshift<1>) -> !fir.array<?x!fir.logical<1>>
-
- ! CHECK: %[[elem_expr:.*]] = fir.do_loop %[[idx:.*]] = %{{.*}} to {{.*}} {
- ! CHECK-DAG: %[[y_elt:.*]] = fir.array_fetch %[[y_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
- ! CHECK-DAG: %[[res_elt:.*]] = fir.array_fetch %[[res_load]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, index) -> !fir.logical<1>
- ! CHECK-DAG: %[[y_elt_i1:.*]] = fir.convert %[[y_elt]] : (!fir.logical<1>) -> i1
- ! CHECK-DAG: %[[res_elt_i1:.*]] = fir.convert %[[res_elt]] : (!fir.logical<1>) -> i1
- ! CHECK: %[[neqv_i1:.*]] = arith.cmpi ne, %[[y_elt_i1]], %[[res_elt_i1]] : i1
- ! CHECK: %[[neqv:.*]] = fir.convert %[[neqv_i1]] : (i1) -> !fir.logical<1>
- ! CHECK: fir.array_update %{{.*}} %[[neqv]], %[[idx]] : (!fir.array<?x!fir.logical<1>>, !fir.logical<1>, index) -> !fir.array<?x!fir.logical<1>>
+ ! CHECK: %[[xdecl:.*]]:2 = hlfir.declare %[[arg0]]{{.*}}{uniq_name = "_QMtest2Fin_elem_exprEx"}
+ ! CHECK: %[[ydecl:.*]]:2 = hlfir.declare %[[arg1]]{{.*}}{uniq_name = "_QMtest2Fin_elem_exprEy"}
+ ! CHECK: %[[zdecl:.*]]:2 = hlfir.declare %[[arg2]]{{.*}}{uniq_name = "_QMtest2Fin_elem_exprEz"}
+ ! CHECK: %[[c1:.*]] = arith.constant 1 : i32
+ ! CHECK: %[[all:.*]] = hlfir.all %[[xdecl]]#0 dim %[[c1]] : (!fir.box<!fir.array<?x?x!fir.logical<1>>>, i32) -> !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: %[[ydims:.*]]:3 = fir.box_dims %[[ydecl]]#0, %{{.*}} : (!fir.box<!fir.array<?x!fir.logical<1>>>, index) -> (index, index, index)
+ ! CHECK: %[[shape:.*]] = fir.shape %[[ydims]]#1 : (index) -> !fir.shape<1>
+ ! CHECK: %[[elem:.*]] = hlfir.elemental %[[shape]] unordered : (!fir.shape<1>) -> !hlfir.expr<?x!fir.logical<1>> {
+ ! CHECK: %[[ydes:.*]] = hlfir.designate %[[ydecl]]#0 (%{{.*}}) : (!fir.box<!fir.array<?x!fir.logical<1>>>, index) -> !fir.ref<!fir.logical<1>>
+ ! CHECK: %[[allval:.*]] = hlfir.apply %[[all]], %{{.*}} : (!hlfir.expr<?x!fir.logical<1>>, index) -> !fir.logical<1>
+ ! CHECK: %[[yval:.*]] = fir.load %[[ydes]] : !fir.ref<!fir.logical<1>>
+ ! CHECK: %[[neqv:.*]] = fir.neqv %[[yval]], %[[allval]] : !fir.logical<1>
+ ! CHECK: hlfir.yield_element %[[neqv]] : !fir.logical<1>
! CHECK: }
- ! CHECK: fir.array_merge_store %[[z_load]], %[[elem_expr]] to %[[arg2]] : !fir.array<?x!fir.logical<1>>, !fir.array<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
+ ! CHECK: hlfir.assign %[[elem]] to %[[zdecl]]#0 : !hlfir.expr<?x!fir.logical<1>>, !fir.box<!fir.array<?x!fir.logical<1>>>
+ ! CHECK: hlfir.destroy %[[elem]] : !hlfir.expr<?x!fir.logical<1>>
+ ! CHECK: hlfir.destroy %[[all]] : !hlfir.expr<?x!fir.logical<1>>
z = y .neqv. all(x, 1)
- ! CHECK: fir.freemem %[[res_addr]] : !fir.heap<!fir.array<?x!fir.logical<1>>>
end subroutine
! CSHIFT
! CHECK-LABEL: func @_QMtest2Pcshift_test() {
- ! CHECK: %[[VAL_0:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
- ! CHECK: %[[VAL_1:.*]] = fir.alloca i32
- ! CHECK: %[[VAL_2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
- ! CHECK: %[[VAL_3:.*]] = arith.constant 3 : index
- ! CHECK: %[[VAL_4:.*]] = arith.constant 3 : index
! CHECK: %[[VAL_5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "array", uniq_name = "_QMtest2Fcshift_testEarray"}
- ! CHECK: %[[VAL_6:.*]] = arith.constant 3 : index
- ! CHECK: %[[VAL_7:.*]] = arith.constant 3 : index
+ ! CHECK: %[[ARRAY_DECL:.*]]:2 = hlfir.declare %[[VAL_5]](%{{.*}}) {uniq_name = "_QMtest2Fcshift_testEarray"}
! CHECK: %[[VAL_8:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Fcshift_testEresult"}
- ! CHECK: %[[VAL_9:.*]] = arith.constant 3 : index
+ ! CHECK: %[[RESULT_DECL:.*]]:2 = hlfir.declare %[[VAL_8]](%{{.*}}) {uniq_name = "_QMtest2Fcshift_testEresult"}
! CHECK: %[[VAL_10:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "shift", uniq_name = "_QMtest2Fcshift_testEshift"}
- ! CHECK: %[[VAL_11:.*]] = arith.constant 6 : index
+ ! CHECK: %[[SHIFT_DECL:.*]]:2 = hlfir.declare %[[VAL_10]](%{{.*}}) {uniq_name = "_QMtest2Fcshift_testEshift"}
! CHECK: %[[VAL_12:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vector", uniq_name = "_QMtest2Fcshift_testEvector"}
- ! CHECK: %[[VAL_13:.*]] = arith.constant 6 : index
+ ! CHECK: %[[VECTOR_DECL:.*]]:2 = hlfir.declare %[[VAL_12]](%{{.*}}) {uniq_name = "_QMtest2Fcshift_testEvector"}
! CHECK: %[[VAL_14:.*]] = fir.alloca !fir.array<6xi32> {bindc_name = "vectorresult", uniq_name = "_QMtest2Fcshift_testEvectorresult"}
- ! CHECK: %[[VAL_15:.*]] = fir.shape %[[VAL_6]], %[[VAL_7]] : (index, index) -> !fir.shape<2>
- ! CHECK: %[[VAL_16:.*]] = fir.array_load %[[VAL_8]](%[[VAL_15]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
- ! CHECK: %[[VAL_17:.*]] = arith.constant 2 : i32
- ! CHECK: %[[VAL_18:.*]] = fir.shape %[[VAL_3]], %[[VAL_4]] : (index, index) -> !fir.shape<2>
- ! CHECK: %[[VAL_19:.*]] = fir.embox %[[VAL_5]](%[[VAL_18]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
- ! CHECK: %[[VAL_20:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[VAL_21:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_22:.*]] = fir.shape %[[VAL_21]], %[[VAL_21]] : (index, index) -> !fir.shape<2>
- ! CHECK: %[[VAL_23:.*]] = fir.embox %[[VAL_20]](%[[VAL_22]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
- ! CHECK: fir.store %[[VAL_23]] to %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK: %[[VAL_24:.*]] = fir.shape %[[VAL_9]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_25:.*]] = fir.embox %[[VAL_10]](%[[VAL_24]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
- ! CHECK: %[[VAL_26:.*]] = fir.address_of(@_QQcl{{.*}}) : !fir.ref<!fir.char<1,
- ! CHECK: %[[VAL_27:.*]] = arith.constant {{[0-9]+}} : i32
- ! CHECK: %[[VAL_28:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK: %[[VAL_29:.*]] = fir.convert %[[VAL_19]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
- ! CHECK: %[[VAL_30:.*]] = fir.convert %[[VAL_25]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
- ! CHECK: %[[VAL_31:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
- ! CHECK: fir.call @_FortranACshift(%[[VAL_28]], %[[VAL_29]], %[[VAL_30]], %[[VAL_17]], %[[VAL_31]], %[[VAL_27]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, i32, !fir.ref<i8>, i32) -> ()
- ! CHECK: %[[VAL_33:.*]] = fir.load %[[VAL_2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK: %[[VAL_34:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_35:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_34]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
- ! CHECK: %[[VAL_36:.*]] = arith.constant 1 : index
- ! CHECK: %[[VAL_37:.*]]:3 = fir.box_dims %[[VAL_33]], %[[VAL_36]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>, index) -> (index, index, index)
- ! CHECK: %[[VAL_38:.*]] = fir.box_addr %[[VAL_33]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[VAL_39:.*]] = fir.shape_shift %[[VAL_35]]#0, %[[VAL_35]]#1, %[[VAL_37]]#0, %[[VAL_37]]#1 : (index, index, index, index) -> !fir.shapeshift<2>
- ! CHECK: %[[VAL_40:.*]] = fir.array_load %[[VAL_38]](%[[VAL_39]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shapeshift<2>) -> !fir.array<?x?xi32>
- ! CHECK: %[[VAL_41:.*]] = arith.constant 1 : index
- ! CHECK: %[[VAL_42:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_43:.*]] = arith.subi %[[VAL_6]], %[[VAL_41]] : index
- ! CHECK: %[[VAL_44:.*]] = arith.subi %[[VAL_7]], %[[VAL_41]] : index
- ! CHECK: %[[VAL_45:.*]] = fir.do_loop %[[VAL_46:.*]] = %[[VAL_42]] to %[[VAL_44]] step %[[VAL_41]] unordered iter_args(%[[VAL_47:.*]] = %[[VAL_16]]) -> (!fir.array<3x3xi32>) {
- ! CHECK: %[[VAL_48:.*]] = fir.do_loop %[[VAL_49:.*]] = %[[VAL_42]] to %[[VAL_43]] step %[[VAL_41]] unordered iter_args(%[[VAL_50:.*]] = %[[VAL_47]]) -> (!fir.array<3x3xi32>) {
- ! CHECK: %[[VAL_51:.*]] = fir.array_fetch %[[VAL_40]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<?x?xi32>, index, index) -> i32
- ! CHECK: %[[VAL_52:.*]] = fir.array_update %[[VAL_50]], %[[VAL_51]], %[[VAL_49]], %[[VAL_46]] : (!fir.array<3x3xi32>, i32, index, index) -> !fir.array<3x3xi32>
- ! CHECK: fir.result %[[VAL_52]] : !fir.array<3x3xi32>
- ! CHECK: }
- ! CHECK: fir.result %[[VAL_53:.*]] : !fir.array<3x3xi32>
- ! CHECK: }
- ! CHECK: fir.array_merge_store %[[VAL_16]], %[[VAL_54:.*]] to %[[VAL_8]] : !fir.array<3x3xi32>, !fir.array<3x3xi32>, !fir.ref<!fir.array<3x3xi32>>
- ! CHECK: fir.freemem %[[VAL_38]] : !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[VAL_55:.*]] = fir.shape %[[VAL_13]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_56:.*]] = fir.array_load %[[VAL_14]](%[[VAL_55]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.array<6xi32>
- ! CHECK: %[[VAL_57:.*]] = arith.constant 3 : i32
- ! CHECK: fir.store %[[VAL_57]] to %[[VAL_1]] : !fir.ref<i32>
- ! CHECK: %[[VAL_58:.*]] = fir.shape %[[VAL_11]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_59:.*]] = fir.embox %[[VAL_12]](%[[VAL_58]]) : (!fir.ref<!fir.array<6xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<6xi32>>
- ! CHECK: %[[VAL_60:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi32>>
- ! CHECK: %[[VAL_61:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_62:.*]] = fir.shape %[[VAL_61]] : (index) -> !fir.shape<1>
- ! CHECK: %[[VAL_63:.*]] = fir.embox %[[VAL_60]](%[[VAL_62]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shape<1>) -> !fir.box<!fir.heap<!fir.array<?xi32>>>
- ! CHECK: fir.store %[[VAL_63]] to %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
- ! CHECK: %[[VAL_64:.*]] = fir.load %[[VAL_1]] : !fir.ref<i32>
- ! CHECK: %[[VAL_65:.*]] = fir.address_of(@_QQclX{{.*}}) : !fir.ref<!fir.char<1,
- ! CHECK: %[[VAL_66:.*]] = arith.constant {{[0-9]+}} : i32
- ! CHECK: %[[VAL_67:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK: %[[VAL_68:.*]] = fir.convert %[[VAL_59]] : (!fir.box<!fir.array<6xi32>>) -> !fir.box<none>
- ! CHECK: %[[VAL_69:.*]] = fir.convert %[[VAL_64]] : (i32) -> i64
- ! CHECK: %[[VAL_70:.*]] = fir.convert %[[VAL_65]] : (!fir.ref<!fir.char<1,{{[0-9]+}}>>) -> !fir.ref<i8>
- ! CHECK: fir.call @_FortranACshiftVector(%[[VAL_67]], %[[VAL_68]], %[[VAL_69]], %[[VAL_70]], %[[VAL_66]]) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, i64, !fir.ref<i8>, i32) -> ()
- ! CHECK: %[[VAL_72:.*]] = fir.load %[[VAL_0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
- ! CHECK: %[[VAL_73:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_74:.*]]:3 = fir.box_dims %[[VAL_72]], %[[VAL_73]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>, index) -> (index, index, index)
- ! CHECK: %[[VAL_75:.*]] = fir.box_addr %[[VAL_72]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
- ! CHECK: %[[VAL_76:.*]] = fir.shape_shift %[[VAL_74]]#0, %[[VAL_74]]#1 : (index, index) -> !fir.shapeshift<1>
- ! CHECK: %[[VAL_77:.*]] = fir.array_load %[[VAL_75]](%[[VAL_76]]) : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>) -> !fir.array<?xi32>
- ! CHECK: %[[VAL_78:.*]] = arith.constant 1 : index
- ! CHECK: %[[VAL_79:.*]] = arith.constant 0 : index
- ! CHECK: %[[VAL_80:.*]] = arith.subi %[[VAL_13]], %[[VAL_78]] : index
- ! CHECK: %[[VAL_81:.*]] = fir.do_loop %[[VAL_82:.*]] = %[[VAL_79]] to %[[VAL_80]] step %[[VAL_78]] unordered iter_args(%[[VAL_83:.*]] = %[[VAL_56]]) -> (!fir.array<6xi32>) {
- ! CHECK: %[[VAL_84:.*]] = fir.array_fetch %[[VAL_77]], %[[VAL_82]] : (!fir.array<?xi32>, index) -> i32
- ! CHECK: %[[VAL_85:.*]] = fir.array_update %[[VAL_83]], %[[VAL_84]], %[[VAL_82]] : (!fir.array<6xi32>, i32, index) -> !fir.array<6xi32>
- ! CHECK: fir.result %[[VAL_85]] : !fir.array<6xi32>
- ! CHECK: }
- ! CHECK: fir.array_merge_store %[[VAL_56]], %[[VAL_86:.*]] to %[[VAL_14]] : !fir.array<6xi32>, !fir.array<6xi32>, !fir.ref<!fir.array<6xi32>>
- ! CHECK: fir.freemem %[[VAL_75]] : !fir.heap<!fir.array<?xi32>>
+ ! CHECK: %[[VECTORRESULT_DECL:.*]]:2 = hlfir.declare %[[VAL_14]](%{{.*}}) {uniq_name = "_QMtest2Fcshift_testEvectorresult"}
+ ! CHECK: %[[C2:.*]] = arith.constant 2 : i32
+ ! CHECK: %[[CSHIFT1:.*]] = hlfir.cshift %[[ARRAY_DECL]]#0 %[[SHIFT_DECL]]#0 dim %[[C2]] : (!fir.ref<!fir.array<3x3xi32>>, !fir.ref<!fir.array<3xi32>>, i32) -> !hlfir.expr<3x3xi32>
+ ! CHECK: hlfir.assign %[[CSHIFT1]] to %[[RESULT_DECL]]#0 : !hlfir.expr<3x3xi32>, !fir.ref<!fir.array<3x3xi32>>
+ ! CHECK: hlfir.destroy %[[CSHIFT1]] : !hlfir.expr<3x3xi32>
+ ! CHECK: %[[C3:.*]] = arith.constant 3 : i32
+ ! CHECK: %[[CSHIFT2:.*]] = hlfir.cshift %[[VECTOR_DECL]]#0 %[[C3]] : (!fir.ref<!fir.array<6xi32>>, i32) -> !hlfir.expr<6xi32>
+ ! CHECK: hlfir.assign %[[CSHIFT2]] to %[[VECTORRESULT_DECL]]#0 : !hlfir.expr<6xi32>, !fir.ref<!fir.array<6xi32>>
+ ! CHECK: hlfir.destroy %[[CSHIFT2]] : !hlfir.expr<6xi32>
! CHECK: return
! CHECK: }
@@ -241,49 +151,38 @@ subroutine unpack_test()
! CHECK-DAG: %[[a1:.*]] = fir.alloca i32
! CHECK-DAG: %[[a2:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?x?xi32>>>
! CHECK-DAG: %[[a3:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "field", uniq_name = "_QMtest2Funpack_testEfield"}
+ ! CHECK-DAG: %[[FIELD_DECL:.*]]:2 = hlfir.declare %[[a3]]{{.*}}{uniq_name = "_QMtest2Funpack_testEfield"}
! CHECK-DAG: %[[a4:.*]] = fir.alloca !fir.array<3x3x!fir.logical<4>> {bindc_name = "mask", uniq_name = "_QMtest2Funpack_testEmask"}
+ ! CHECK-DAG: %[[MASK_DECL:.*]]:2 = hlfir.declare %[[a4]]{{.*}}{uniq_name = "_QMtest2Funpack_testEmask"}
! CHECK-DAG: %[[a5:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "result", uniq_name = "_QMtest2Funpack_testEresult"}
+ ! CHECK-DAG: %[[RESULT_DECL:.*]]:2 = hlfir.declare %[[a5]]{{.*}}{uniq_name = "_QMtest2Funpack_testEresult"}
! CHECK-DAG: %[[a6:.*]] = fir.alloca !fir.array<3xi32> {bindc_name = "vector", uniq_name = "_QMtest2Funpack_testEvector"}
- ! CHECK: %[[a7:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK-NEXT: %[[a8:.*]] = fir.array_load %[[a5]](%[[a7]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.array<3x3xi32>
- ! CHECK: %[[a9:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
- ! CHECK: %[[a10:.*]] = fir.embox %[[a6]](%[[a9]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
- ! CHECK: %[[a11:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK: %[[a12:.*]] = fir.embox %[[a4]](%[[a11]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
- ! CHECK: %[[a13:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK-NEXT: %[[a14:.*]] = fir.embox %[[a3]](%[[a13]]) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
- ! CHECK: %[[a15:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[a16:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK: %[[a17:.*]] = fir.embox %[[a15]](%[[a16]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
- ! CHECK-NEXT: fir.store %[[a17]] to %[[a2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK-DAG: %[[a19:.*]] = fir.convert %[[a2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK-DAG: %[[a20:.*]] = fir.convert %[[a10]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a21:.*]] = fir.convert %[[a12]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
- ! CHECK-DAG: %[[a22:.*]] = fir.convert %[[a14]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
- ! CHECK: fir.call @_FortranAUnpack(%[[a19]], %[[a20]], %[[a21]], %[[a22]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
- ! CHECK-NEXT: %[[a22:.*]] = fir.load %{{.*}} : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK: %[[a25:.*]] = fir.box_addr %[[a22]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: fir.freemem %[[a25]] : !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[a36:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK: %[[a38:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
- ! CHECK-NEXT: %[[a39:.*]] = fir.embox %[[a6]](%[[a38]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
- ! CHECK: %[[a40:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK-NEXT: %[[a41:.*]] = fir.embox %[[a4]](%[[a40]]) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
- ! CHECK: %[[a42:.*]] = fir.embox %[[a1]] : (!fir.ref<i32>) -> !fir.box<i32>
- ! CHECK: %[[a43:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: %[[a44:.*]] = fir.shape %{{.*}}, %{{.*}} : (index, index) -> !fir.shape<2>
- ! CHECK: %[[a45:.*]] = fir.embox %[[a43]](%[[a44]]) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
- ! CHECK-NEXT: fir.store %[[a45]] to %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK: %[[a47:.*]] = fir.convert %[[a0]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
- ! CHECK: %[[a48:.*]] = fir.convert %[[a39]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
- ! CHECK: %[[a49:.*]] = fir.convert %[[a41]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
- ! CHECK: %[[a50:.*]] = fir.convert %[[a42]] : (!fir.box<i32>) -> !fir.box<none>
+ ! CHECK-DAG: %[[VECTOR_DECL:.*]]:2 = hlfir.declare %[[a6]]{{.*}}{uniq_name = "_QMtest2Funpack_testEvector"}
+ ! CHECK: %[[v_embox:.*]] = fir.embox %[[VECTOR_DECL]]#0(%{{.*}}) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
+ ! CHECK: %[[m_embox:.*]] = fir.embox %[[MASK_DECL]]#0(%{{.*}}) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
+ ! CHECK: %[[f_embox:.*]] = fir.embox %[[FIELD_DECL]]#0(%{{.*}}) : (!fir.ref<!fir.array<3x3xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3xi32>>
+ ! CHECK: %[[zero:.*]] = fir.zero_bits !fir.heap<!fir.array<?x?xi32>>
+ ! CHECK: %[[zero_embox:.*]] = fir.embox %[[zero]](%{{.*}}) : (!fir.heap<!fir.array<?x?xi32>>, !fir.shape<2>) -> !fir.box<!fir.heap<!fir.array<?x?xi32>>>
+ ! CHECK: fir.store %[[zero_embox]] to %[[a2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
+ ! CHECK: %[[r_arg:.*]] = fir.convert %[[a2]] : (!fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>) -> !fir.ref<!fir.box<none>>
+ ! CHECK: %[[v_arg:.*]] = fir.convert %[[v_embox]] : (!fir.box<!fir.array<3xi32>>) -> !fir.box<none>
+ ! CHECK: %[[m_arg:.*]] = fir.convert %[[m_embox]] : (!fir.box<!fir.array<3x3x!fir.logical<4>>>) -> !fir.box<none>
+ ! CHECK: %[[f_arg:.*]] = fir.convert %[[f_embox]] : (!fir.box<!fir.array<3x3xi32>>) -> !fir.box<none>
+ ! CHECK: fir.call @_FortranAUnpack(%[[r_arg]], %[[v_arg]], %[[m_arg]], %[[f_arg]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
+ ! CHECK: %[[r_load:.*]] = fir.load %[[a2]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
+ ! CHECK: %[[r_addr:.*]] = fir.box_addr %[[r_load]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
+ ! CHECK: %[[r_decl:.*]]:2 = hlfir.declare %[[r_addr]](%{{.*}}) {uniq_name = ".tmp.intrinsic_result"}
+ ! CHECK: %[[r_expr:.*]] = hlfir.as_expr %[[r_decl]]#0 move %{{.*}} : (!fir.box<!fir.array<?x?xi32>>, i1) -> !hlfir.expr<?x?xi32>
+ ! CHECK: hlfir.assign %[[r_expr]] to %[[RESULT_DECL]]#0 : !hlfir.expr<?x?xi32>, !fir.ref<!fir.array<3x3xi32>>
+ ! CHECK: hlfir.destroy %[[r_expr]] : !hlfir.expr<?x?xi32>
+ ! CHECK: %[[c343:.*]] = arith.constant 343 : i32
+ ! CHECK: %[[v_embox2:.*]] = fir.embox %[[VECTOR_DECL]]#0(%{{.*}}) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<3xi32>>
+ ! CHECK: %[[m_embox2:.*]] = fir.embox %[[MASK_DECL]]#0(%{{.*}}) : (!fir.ref<!fir.array<3x3x!fir.logical<4>>>, !fir.shape<2>) -> !fir.box<!fir.array<3x3x!fir.logical<4>>>
+ ! CHECK: fir.store %[[c343]] to %[[a1]] : !fir.ref<i32>
+ ! CHECK: %[[scalar_embox:.*]] = fir.embox %[[a1]] : (!fir.ref<i32>) -> !fir.box<i32>
result = unpack(vector, mask, 343)
- ! CHECK: fir.call @_FortranAUnpack(%[[a47]], %[[a48]], %[[a49]], %[[a50]], %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
- ! CHECK: %[[a53:.*]] = fir.load %[[a0]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?x?xi32>>>>
- ! CHECK: %[[a56:.*]] = fir.box_addr %[[a53]] : (!fir.box<!fir.heap<!fir.array<?x?xi32>>>) -> !fir.heap<!fir.array<?x?xi32>>
- ! CHECK: fir.freemem %[[a56]] : !fir.heap<!fir.array<?x?xi32>>
- ! CHECK-NEXT: return
+ ! CHECK: fir.call @_FortranAUnpack(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {{.*}}: (!fir.ref<!fir.box<none>>, !fir.box<none>, !fir.box<none>, !fir.box<none>, !fir.ref<i8>, i32) -> ()
+ ! CHECK: return
end subroutine unpack_test
end module
diff --git a/flang/test/Transforms/stack-arrays.f90 b/flang/test/Transforms/stack-arrays.f90
deleted file mode 100644
index 2c8a6fc15504a..0000000000000
--- a/flang/test/Transforms/stack-arrays.f90
+++ /dev/null
@@ -1,154 +0,0 @@
-! RUN: %flang_fc1 -emit-fir -flang-deprecated-no-hlfir %s -o - | fir-opt --array-value-copy | fir-opt --stack-arrays | FileCheck %s
-
-! In order to verify the whole MLIR pipeline, make the driver generate LLVM IR.
-! This is only to check that -fstack-arrays enables the stack-arrays pass so
-! only check the first example
-! RUN: %flang_fc1 -emit-llvm -flang-deprecated-no-hlfir -o - -fstack-arrays %s | FileCheck --check-prefix=LLVM-IR %s
-
-! check simple array value copy case
-subroutine array_value_copy_simple(arr)
- integer, intent(inout) :: arr(4)
- arr(3:4) = arr(1:2)
-end subroutine
-! CHECK-LABEL: func.func @_QParray_value_copy_simple(%arg0: !fir.ref<!fir.array<4xi32>>
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: fir.alloca !fir.array<4xi32>
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
-
-! LLVM-IR: array_value_copy_simple
-! LLVM-IR-NOT: malloc
-! LLVM-IR-NOT: free
-! LLVM-IR: alloca [4 x i32]
-! LLVM-IR-NOT: malloc
-! LLVM-IR-NOT: free
-! LLVM-IR: ret void
-! LLVM-IR-NEXT: }
-
-! check complex array value copy case
-module stuff
- type DerivedWithAllocatable
- integer, dimension(:), allocatable :: dat
- end type
-
- contains
- subroutine array_value_copy_complex(arr)
- type(DerivedWithAllocatable), intent(inout) :: arr(:)
- arr(3:4) = arr(1:2)
- end subroutine
-end module
-! CHECK: func.func
-! CHECK-SAME: array_value_copy_complex
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: fir.alloca !fir.array<?x!fir.type<_QMstuffTderivedwithallocatable
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine parameter_array_init
- integer, parameter :: p(100) = 42
- call use_p(p)
-end subroutine
-! CHECK: func.func
-! CHECK-SAME: parameter_array_init
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: fir.alloca !fir.array<100xi32>
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine test_vector_subscripted_section_to_box(v, x)
- interface
- subroutine takes_box(y)
- real :: y(:)
- end subroutine
- end interface
-
- integer :: v(:)
- real :: x(:)
- call takes_box(x(v))
-end subroutine
-! CHECK: func.func
-! CHECK-SAME: test_vector_subscripted_section_to_box
-! CHECK-NOT: fir.allocmem
-! CHECK: fir.alloca !fir.array<?xf32>
-! CHECK-NOT: fir.allocmem
-! CHECK: fir.call @_QPtakes_box
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine call_parenthesized_arg(x)
- integer :: x(100)
- call bar((x))
-end subroutine
-! CHECK: func.func
-! CHECK-SAME: call_parenthesized_arg
-! CHECK-NOT: fir.allocmem
-! CHECK: fir.alloca !fir.array<100xi32>
-! CHECK-NOT: fir.allocmem
-! CHECK: fir.call @_QPbar
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine where_allocatable_assignments(a, b)
- integer :: a(:)
- integer, allocatable :: b(:)
- where(b > 0)
- b = a
- elsewhere
- b(:) = 0
- end where
-end subroutine
-! TODO: broken: passing allocation through fir.result
-! CHECK: func.func
-! CHECK-SAME: where_allocatable_assignments
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine array_constructor(a, b)
- real :: a(5), b
- real, external :: f
- a = [f(b), f(b+1), f(b+2), f(b+5), f(b+11)]
-end subroutine
-! TODO: broken: realloc
-! CHECK: func.func
-! CHECK-SAME: array_constructor
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine sequence(seq, n)
- integer :: n, seq(n)
- seq = [(i,i=1,n)]
-end subroutine
-! TODO: broken: realloc
-! CHECK: func.func
-! CHECK-SAME: sequence
-! CHECK: return
-! CHECK-NEXT: }
-
-subroutine CFGLoop(x)
- integer, parameter :: k = 100, m=1000000, n = k*m
- integer :: x(n)
- logical :: has_error
-
- do i=0,m-1
- x(k*i+1:k*(i+1)) = x(k*(i+1):k*i+1:-1)
- if (has_error(x, k)) stop
- end do
-end subroutine
-! CHECK: func.func
-! CHECK-SAME: cfgloop
-! CHECK-NEXT: %[[MEM:.*]] = fir.alloca !fir.array<100000000xi32>
-! CHECK-NOT: fir.allocmem
-! CHECK-NOT: fir.freemem
-! CHECK: return
-! CHECK-NEXT: }
More information about the flang-commits
mailing list