mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-27 16:46:08 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/flang/test/Lower/array-constructor-2.f90

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

178 lines
8.2 KiB
Fortran
Raw Normal View History

[flang] Turn on use-desc-for-alloc by default Currently, local allocatables and contiguous/scalar pointers (and some other conditions) are lowered to a set of independent variables in FIR (one for the address, one for each bound and one for character length). The intention was to help LLVM get rids of descriptors. But LLVM knows how to do that anyway in those cases: ``` subroutine foo(x) real, target :: x(100) real, pointer, contiguous :: p(:) p => x call bar(p(50)) end subroutine ``` The output fir the option on or off is the same after llvm opt -O1, there is no descriptor anymore, the indirection is removed. ``` define void @foo_(ptr %0) local_unnamed_addr { %2 = getelementptr [100 x float], ptr %0, i64 0, i64 49 tail call void @bar_(ptr %2) ret void } ``` So the benefit of not using a descriptor in lowering is questionable, and although it is abstracted as much as possible in the so called MutableBoxValue class that represent allocatable/pointer in lowering it is still causing bugs from time to time, and will also be a bit problematic when emitting debug info for the pointer/allocatable. In HLFIR lowering, the simplification to always use a descriptor in lowering was already made. This patch allows decorrelating the impact from this change from the bigger impact HLFIR will have so that it is easier to get feedback if this causes performance issues. The lowering tests relying on the previous behavior are only updated to set back this option to true. The reason is that I think we should preserve coverage of the code dealing with the "non descriptor" approach in lowering until we actually get rid of it. The other reason is that the test will have to be or are already covered by equivalent HLFIR tests, which use descriptors. Differential Revision: https://reviews.llvm.org/D148910
2023-04-24 09:04:57 +02:00
! RUN: bbc --use-desc-for-alloc=false %s -o - | FileCheck %s
[flang] Add array constructor lowering tests This patch adds some tests for the lowering of array constructors. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D121945 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-17 21:39:19 +01:00
! Constant array ctor.
! CHECK-LABEL: func @_QPtest1(
subroutine test1(a, b)
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
real :: a(3)
integer :: b(4)
integer, parameter :: constant_array(4) = [6, 7, 42, 9]
! Array ctors for constant arrays should be outlined as constant globals.
! Look at inline constructor case
[flang] Fixed global name creation for literal constants. The global names were created using a hash based on the address of std::vector::data address. Since the memory may be reused by different std::vector's, this may cause non-equivalent constant expressions to map to the same name. This is what is happening in the modified flang/test/Lower/constant-literal-mangling.f90 test. I changed the name creation to use a map between the constant expressions and corresponding unique names. The uniquing is done using a name counter in FirConverter. The effect of this change is that the equivalent constant expressions are now mapped to the same global, and the naming is "stable" (i.e. it does not change from compilation to compilation). Though, the issue is not HLFIR specific it was affecting several tests when using HLFIR lowering. Differential Revision: https://reviews.llvm.org/D150380
2023-05-09 19:50:48 -07:00
! CHECK: %{{.*}} = fir.address_of(@_QQro.3xr4.0) : !fir.ref<!fir.array<3xf32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
a = (/ 1.0, 2.0, 3.0 /)
! Look at PARAMETER case
[flang] Fixed global name creation for literal constants. The global names were created using a hash based on the address of std::vector::data address. Since the memory may be reused by different std::vector's, this may cause non-equivalent constant expressions to map to the same name. This is what is happening in the modified flang/test/Lower/constant-literal-mangling.f90 test. I changed the name creation to use a map between the constant expressions and corresponding unique names. The uniquing is done using a name counter in FirConverter. The effect of this change is that the equivalent constant expressions are now mapped to the same global, and the naming is "stable" (i.e. it does not change from compilation to compilation). Though, the issue is not HLFIR specific it was affecting several tests when using HLFIR lowering. Differential Revision: https://reviews.llvm.org/D150380
2023-05-09 19:50:48 -07:00
! CHECK: %{{.*}} = fir.address_of(@_QQro.4xi4.1) : !fir.ref<!fir.array<4xi32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
b = constant_array
end subroutine test1
! Dynamic array ctor with constant extent.
! CHECK-LABEL: func @_QPtest2(
! CHECK-SAME: %[[a:[^:]*]]: !fir.ref<!fir.array<5xf32>>{{.*}}, %[[b:[^:]*]]: !fir.ref<f32>{{.*}})
subroutine test2(a, b)
real :: a(5), b
real, external :: f
! Look for the 5 store patterns
! CHECK: %[[tmp:.*]] = fir.allocmem !fir.array<5xf32>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: %[[val:.*]] = fir.call @_QPf(%[[b]]) {{.*}}: (!fir.ref<f32>) -> f32
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: %[[loc:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
! CHECK: fir.store %[[val]] to %[[loc]] : !fir.ref<f32>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @_QPf(%{{.*}}) {{.*}}: (!fir.ref<f32>) -> f32
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<5xf32>>, index) -> !fir.ref<f32>
! CHECK: fir.store
! CHECK: fir.call @_QPf(
! CHECK: fir.coordinate_of %
! CHECK: fir.store
! CHECK: fir.call @_QPf(
! CHECK: fir.coordinate_of %
! CHECK: fir.store
! CHECK: fir.call @_QPf(
! CHECK: fir.coordinate_of %
! CHECK: fir.store
! After the ctor done, loop to copy result to `a`
! CHECK-DAG: fir.array_coor %[[tmp:.*]](%
! CHECK-DAG: %[[ai:.*]] = fir.array_coor %[[a]](%
! CHECK: fir.store %{{.*}} to %[[ai]] : !fir.ref<f32>
[flang] Add lowering tests Add lowering tests left behind during the upstreaming. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128721 Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-06-28 15:21:44 +02:00
! CHECK: fir.freemem %[[tmp]] : !fir.heap<!fir.array<5xf32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
a = [f(b), f(b+1), f(b+2), f(b+5), f(b+11)]
end subroutine test2
! Dynamic array ctor with dynamic extent.
! CHECK-LABEL: func @_QPtest3(
! CHECK-SAME: %[[a:.*]]: !fir.box<!fir.array<?xf32>>{{.*}})
subroutine test3(a)
real :: a(:)
real, allocatable :: b(:), c(:)
interface
subroutine test3b(x)
real, allocatable :: x(:)
end subroutine test3b
end interface
interface
function test3c
real, allocatable :: test3c(:)
end function test3c
end interface
! CHECK: fir.call @_QPtest3b
! CHECK: %{{.*}}:3 = fir.box_dims %{{.*}}, %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>, index) -> (index, index, index)
! CHECK: %{{.*}} = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
! CHECK: %[[tmp:.*]] = fir.allocmem f32, %c32
call test3b(b)
! CHECK: %[[hp1:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}} {uniq_name = ".array.expr"}
! CHECK-DAG: %[[rep:.*]] = fir.convert %{{.*}} : (!fir.heap<f32>) -> !fir.ref<i8>
! CHECK-DAG: %[[res:.*]] = fir.convert %{{.*}} : (index) -> i64
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: %{{.*}} = fir.call @realloc(%[[rep]], %[[res]]) {{.*}}: (!fir.ref<i8>, i64) -> !fir.ref<i8>
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: fir.call @_QPtest3c
! CHECK: fir.save_result
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<?xf32>, %{{.*}}#1 {uniq_name = ".array.expr"}
! CHECK: fir.call @realloc
[flang] Update memcpy intrinsic mangling for opaque pointers Flang is manually mangling names for memset/memcpy/memmove intrinsics, so we need to update the mangling to use the opaque pointer format (p0 instead of p0i8).
2022-06-02 12:07:37 +02:00
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: fir.array_coor %[[tmp:.*]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<?xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
! CHECK-NEXT: fir.load
! CHECK-NEXT: fir.array_coor %arg0 %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
! CHECK-NEXT: fir.store
! CHECK: fir.freemem %[[tmp]]
! CHECK: fir.freemem %[[tmp2]]
! CHECK: %[[alli:.*]] = fir.box_addr %{{.*}} : (!fir.box<!fir.heap<!fir.array<?xf32>>>) -> !fir.heap<!fir.array<?xf32>>
! CHECK: fir.freemem %[[alli]]
! CHECK: fir.freemem %[[hp1]]
a = (/ b, test3c() /)
end subroutine test3
! CHECK-LABEL: func @_QPtest4(
subroutine test4(a, b, n1, m1)
real :: a(:)
real :: b(:,:)
integer, external :: f1, f2, f3
! Dynamic array ctor with dynamic extent using implied do loops.
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.pos"}
! CHECK-DAG: fir.alloca index {bindc_name = ".buff.size"}
! CHECK-DAG: %[[c32:.*]] = arith.constant 32 : index
! CHECK: fir.allocmem f32, %[[c32]]
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @_QPf1(%{{.*}}) {{.*}}: (!fir.ref<i32>) -> i32
! CHECK: fir.call @_QPf2(%arg2) {{.*}}: (!fir.ref<i32>) -> i32
! CHECK: fir.call @_QPf3(%{{.*}}) {{.*}}: (!fir.ref<i32>) -> i32
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: %[[q:.*]] = fir.coordinate_of %arg1, %{{.*}}, %{{.*}} : (!fir.box<!fir.array<?x?xf32>>, i64, i64) -> !fir.ref<f32>
! CHECK: %[[q2:.*]] = fir.load %[[q]] : !fir.ref<f32>
! CHECK: fir.store %[[q2]] to %{{.*}} : !fir.ref<f32>
[flang] Add lowering tests Add lowering tests left behind during the upstreaming. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128721 Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-06-28 15:21:44 +02:00
! CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<?xf32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK-NEXT: return
a = [ ((b(i,j), j=f1(i),f2(n1),f3(m1+i)), i=1,n1,m1) ]
end subroutine test4
! CHECK-LABEL: func @_QPtest5(
! CHECK-SAME: %[[a:[^:]*]]: !fir.box<!fir.array<?xf32>>{{.*}}, %[[array2:[^:]*]]: !fir.ref<!fir.array<2xf32>>{{.*}})
subroutine test5(a, array2)
real :: a(:)
real, parameter :: const_array1(2) = [ 1.0, 2.0 ]
real :: array2(2)
! Array ctor with runtime element values and constant extents.
! Concatenation of array values of constant extent.
! CHECK: %[[res:.*]] = fir.allocmem !fir.array<4xf32>
[flang] Fixed global name creation for literal constants. The global names were created using a hash based on the address of std::vector::data address. Since the memory may be reused by different std::vector's, this may cause non-equivalent constant expressions to map to the same name. This is what is happening in the modified flang/test/Lower/constant-literal-mangling.f90 test. I changed the name creation to use a map between the constant expressions and corresponding unique names. The uniquing is done using a name counter in FirConverter. The effect of this change is that the equivalent constant expressions are now mapped to the same global, and the naming is "stable" (i.e. it does not change from compilation to compilation). Though, the issue is not HLFIR specific it was affecting several tests when using HLFIR lowering. Differential Revision: https://reviews.llvm.org/D150380
2023-05-09 19:50:48 -07:00
! CHECK: fir.address_of(@_QQro.2xr4.2) : !fir.ref<!fir.array<2xf32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: %[[tmp1:.*]] = fir.allocmem !fir.array<2xf32>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: %[[tmp2:.*]] = fir.allocmem !fir.array<2xf32>
! CHECK: = fir.array_coor %[[array2]](%{{.*}}) %{{.*}} : (!fir.ref<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
! CHECK: = fir.array_coor %[[tmp2]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<2xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%{{.*}}, %{{.*}}, %{{.*}}, %false{{.*}}) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: = fir.array_coor %{{.*}}(%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<4xf32>>, !fir.shape<1>, index) -> !fir.ref<f32>
! CHECK: = fir.array_coor %[[a]] %{{.*}} : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
[flang] Add lowering tests Add lowering tests left behind during the upstreaming. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128721 Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-06-28 15:21:44 +02:00
! CHECK-DAG: fir.freemem %{{.*}} : !fir.heap<!fir.array<4xf32>>
! CHECK-DAG: fir.freemem %[[tmp2]] : !fir.heap<!fir.array<2xf32>>
! CHECK-DAG: fir.freemem %[[tmp1]] : !fir.heap<!fir.array<2xf32>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: return
a = [ const_array1, array2 ]
end subroutine test5
! CHECK-LABEL: func @_QPtest6(
subroutine test6(c, d, e)
[flang] Compile-time checks for shape conformance on assignments Assignment statements need to check for array shape conformance errors that are discernable at compilation time. Differential Revision: https://reviews.llvm.org/D132161
2022-08-15 13:24:46 -07:00
character(5) :: c(2)
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
character(5) :: d, e
! CHECK: = fir.allocmem !fir.array<2x!fir.char<1,5>>
! CHECK: fir.call @realloc
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%[[to]], %{{.*}}, %{{.*}}, %false) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
! CHECK: fir.call @realloc
! CHECK: %[[t:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.heap<!fir.array<2x!fir.char<1,5>>>, index) -> !fir.ref<!fir.char<1,5>>
! CHECK: %[[to:.*]] = fir.convert %[[t]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<i8>
[flang] Set default to -ffpcontract=fast Following RFC at https://discourse.llvm.org/t/rfc-ffp-contract-default-value/66301 This adds the `fastmath<contract>` attribute to `fir.call` and some floating point arithmetic operations (hence the many test changes). Instead of testing for this specific attribute, I am using a regular expression to match any attributes.
2022-11-11 20:00:18 +00:00
! CHECK: fir.call @llvm.memcpy.p0.p0.i64(%[[to]], %{{.*}}, %{{.*}}, %false) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
[flang] Add lowering tests Add lowering tests left behind during the upstreaming. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128721 Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-06-28 15:21:44 +02:00
! CHECK: fir.freemem %{{.*}} : !fir.heap<!fir.array<2x!fir.char<1,5>>>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
c = (/ d, e /)
end subroutine test6
! CHECK-LABEL: func @_QPtest7(
! CHECK: %[[i:.*]] = fir.convert %{{.*}} : (index) -> i8
! CHECK: %[[und:.*]] = fir.undefined !fir.char<1>
! CHECK: %[[scalar:.*]] = fir.insert_value %[[und]], %[[i]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
! CHECK: ^bb{{[0-9]+}}(%{{.*}}: !fir.heap<!fir.char<1>>): // 2 preds
! CHECK: fir.store %[[scalar]] to %{{.*}} : !fir.ref<!fir.char<1>>
subroutine test7(a, n)
character(1) :: a(n)
a = (/ (CHAR(i), i=1,n) /)
end subroutine test7
[flang] Fixed global name creation for literal constants. The global names were created using a hash based on the address of std::vector::data address. Since the memory may be reused by different std::vector's, this may cause non-equivalent constant expressions to map to the same name. This is what is happening in the modified flang/test/Lower/constant-literal-mangling.f90 test. I changed the name creation to use a map between the constant expressions and corresponding unique names. The uniquing is done using a name counter in FirConverter. The effect of this change is that the equivalent constant expressions are now mapped to the same global, and the naming is "stable" (i.e. it does not change from compilation to compilation). Though, the issue is not HLFIR specific it was affecting several tests when using HLFIR lowering. Differential Revision: https://reviews.llvm.org/D150380
2023-05-09 19:50:48 -07:00
! CHECK: fir.global internal @_QQro.3xr4.0(dense<[1.000000e+00, 2.000000e+00, 3.000000e+00]> : tensor<3xf32>) constant : !fir.array<3xf32>
[flang][NFC] Fix lowering tests indent Remove 2 spaces indent that was introduced by mistake when upstreaming these files.
2022-03-22 12:48:06 -07:00
[flang] Fixed global name creation for literal constants. The global names were created using a hash based on the address of std::vector::data address. Since the memory may be reused by different std::vector's, this may cause non-equivalent constant expressions to map to the same name. This is what is happening in the modified flang/test/Lower/constant-literal-mangling.f90 test. I changed the name creation to use a map between the constant expressions and corresponding unique names. The uniquing is done using a name counter in FirConverter. The effect of this change is that the equivalent constant expressions are now mapped to the same global, and the naming is "stable" (i.e. it does not change from compilation to compilation). Though, the issue is not HLFIR specific it was affecting several tests when using HLFIR lowering. Differential Revision: https://reviews.llvm.org/D150380
2023-05-09 19:50:48 -07:00
! CHECK: fir.global internal @_QQro.4xi4.1(dense<[6, 7, 42, 9]> : tensor<4xi32>) constant : !fir.array<4xi32>
Reference in New Issue Copy Permalink