Debian Codegraph @

flang/test/Transforms/simplify-fir-operations.fir

raw
1 // RUN: fir-opt --split-input-file --simplify-fir-operations %s | FileCheck --check-prefixes=ALL,NOOPT %s
2 // RUN: fir-opt --split-input-file --simplify-fir-operations=prefer-inline-implementation=true %s | FileCheck --check-prefixes=ALL,OPT %s
3
4 func.func @test_none_innermost(%arg0: !fir.box<none>) -> i1 {
5 %0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<none>) -> i1
6 return %0 : i1
7 }
8 // ALL-LABEL: func.func @test_none_innermost(
9 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
10 // ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
11 // ALL: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_0]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
12 // ALL: return %[[VAL_2]] : i1
13
14 // -----
15
16 func.func @test_none_whole(%arg0: !fir.box<none>) -> i1 {
17 %0 = fir.is_contiguous_box %arg0 whole : (!fir.box<none>) -> i1
18 return %0 : i1
19 }
20 // ALL-LABEL: func.func @test_none_whole(
21 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
22 // ALL: %[[VAL_1:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_0]]) : (!fir.box<none>) -> i1
23 // ALL: return %[[VAL_1]] : i1
24 // ALL: }
25
26 // -----
27
28 func.func @test_array_innermost(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
29 %0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<!fir.array<?xf32>>) -> i1
30 return %0 : i1
31 }
32 // ALL-LABEL: func.func @test_array_innermost(
33 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
34 // NOOPT: %[[VAL_1:.*]] = arith.constant 1 : i32
35 // NOOPT: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
36 // NOOPT: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
37 // NOOPT: return %[[VAL_3]] : i1
38 // OPT: %[[VAL_1:.*]] = arith.constant 0 : index
39 // OPT: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> index
40 // OPT: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_1]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
41 // OPT: %[[VAL_4:.*]] = arith.cmpi eq, %[[VAL_2]], %[[VAL_3]]#2 : index
42 // OPT: %[[VAL_5:.*]] = arith.cmpi eq, %[[VAL_3]]#1, %[[VAL_1]] : index
43 // OPT: %[[VAL_6:.*]] = arith.ori %[[VAL_4]], %[[VAL_5]] : i1
44 // OPT: return %[[VAL_6]] : i1
45
46 // -----
47
48 func.func @test_array_whole(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
49 %0 = fir.is_contiguous_box %arg0 whole : (!fir.box<!fir.array<?xf32>>) -> i1
50 return %0 : i1
51 }
52 // ALL-LABEL: func.func @test_array_whole(
53 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xf32>>) -> i1 {
54 // NOOPT: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
55 // NOOPT: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
56 // NOOPT: return %[[VAL_2]] : i1
57 // OPT: %[[VAL_1:.*]] = arith.constant 0 : index
58 // OPT: %[[VAL_2:.*]] = fir.box_elesize %[[VAL_0]] : (!fir.box<!fir.array<?xf32>>) -> index
59 // OPT: %[[VAL_3:.*]]:3 = fir.box_dims %[[VAL_0]], %[[VAL_1]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
60 // OPT: %[[VAL_4:.*]] = arith.cmpi eq, %[[VAL_2]], %[[VAL_3]]#2 : index
61 // OPT: %[[VAL_5:.*]] = arith.cmpi eq, %[[VAL_3]]#1, %[[VAL_1]] : index
62 // OPT: %[[VAL_6:.*]] = arith.ori %[[VAL_4]], %[[VAL_5]] : i1
63 // OPT: return %[[VAL_6]] : i1
64
65 // -----
66
67 func.func @test_assumed_rank_innermost(%arg0: !fir.box<!fir.array<*:f32>>) -> i1 {
68 %0 = fir.is_contiguous_box %arg0 innermost : (!fir.box<!fir.array<*:f32>>) -> i1
69 return %0 : i1
70 }
71 // ALL-LABEL: func.func @test_assumed_rank_innermost(
72 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
73 // ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
74 // ALL: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
75 // ALL: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
76 // ALL: return %[[VAL_3]] : i1
77
78 // -----
79
80 func.func @test_assumed_rank_whole(%arg0: !fir.box<!fir.array<*:f32>>) -> i1 {
81 %0 = fir.is_contiguous_box %arg0 whole : (!fir.box<!fir.array<*:f32>>) -> i1
82 return %0 : i1
83 }
84 // ALL-LABEL: func.func @test_assumed_rank_whole(
85 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> i1 {
86 // ALL: %[[VAL_1:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
87 // ALL: %[[VAL_2:.*]] = fir.call @_FortranAIsContiguous(%[[VAL_1]]) : (!fir.box<none>) -> i1
88 // ALL: return %[[VAL_2]] : i1
89 // ALL: }
90
91 // -----
92
93 func.func @test_scalar_upoly(%arg0: !fir.class<none>) -> i1 {
94 %0 = fir.is_contiguous_box %arg0 innermost : (!fir.class<none>) -> i1
95 return %0 : i1
96 }
97 // ALL-LABEL: func.func @test_scalar_upoly(
98 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.class<none>) -> i1 {
99 // ALL: %[[VAL_1:.*]] = arith.constant 1 : i32
100 // ALL: %[[VAL_2:.*]] = fir.convert %[[VAL_0]] : (!fir.class<none>) -> !fir.box<none>
101 // ALL: %[[VAL_3:.*]] = fir.call @_FortranAIsContiguousUpTo(%[[VAL_2]], %[[VAL_1]]) : (!fir.box<none>, i32) -> i1
102 // ALL: return %[[VAL_3]] : i1
103
104 // -----
105
106 func.func @test_none(%arg0: !fir.box<none>) -> i16 {
107 %0 = fir.box_total_elements %arg0 : (!fir.box<none>) -> i16
108 return %0 : i16
109 }
110 // ALL-LABEL: func.func @test_none(
111 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i16 {
112 // ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
113 // ALL: %[[VAL_1:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
114 // ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
115 // ALL: %[[VAL_5:.*]] = fir.call @_FortranASize(%[[VAL_0]], %[[VAL_4]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
116 // ALL: %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> i16
117 // ALL: return %[[VAL_6]] : i16
118 // ALL: }
119
120 // -----
121
122 func.func @test_array(%arg0: !fir.box<!fir.array<?x?xf32>>) -> i32 {
123 %0 = fir.box_total_elements %arg0 : (!fir.box<!fir.array<?x?xf32>>) -> i32
124 return %0 : i32
125 }
126 // ALL-LABEL: func.func @test_array(
127 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?x?xf32>>) -> i32 {
128 // ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
129 // ALL: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
130 // ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
131 // ALL: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
132 // ALL: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
133 // ALL: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> i32
134 // ALL: return %[[VAL_7]] : i32
135 // ALL: }
136
137 // -----
138
139 func.func @test_assumed_rank(%arg0: !fir.box<!fir.array<*:f32>>) -> index {
140 %0 = fir.box_total_elements %arg0 : (!fir.box<!fir.array<*:f32>>) -> index
141 return %0 : index
142 }
143 // ALL-LABEL: func.func @test_assumed_rank(
144 // ALL-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> index {
145 // ALL: %[[VAL_3:.*]] = arith.constant {{.*}} : i32
146 // ALL: %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
147 // ALL: %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
148 // ALL: %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
149 // ALL: %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
150 // ALL: %[[VAL_7:.*]] = fir.convert %[[VAL_6]] : (i64) -> index
151 // ALL: return %[[VAL_7]] : index
152 // ALL: }