1! RUN: bbc -emit-fir %s -o - | FileCheck %s
2
3! CHECK-LABEL: func @_QQmain() {
4program nested_where
5
6  ! CHECK:  %[[VAL_0:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
7  ! CHECK:  %[[VAL_1:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
8  ! CHECK:  %[[VAL_2:.*]] = fir.alloca i32 {adapt.valuebyref, bindc_name = "i"}
9  ! CHECK:  %[[VAL_3:.*]] = fir.alloca tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>
10  ! CHECK:  %[[VAL_4:.*]] = fir.alloca tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>
11  ! CHECK:  %[[VAL_5:.*]] = fir.address_of(@_QFEa) : !fir.ref<!fir.array<3xi32>>
12  ! CHECK:  %[[VAL_6:.*]] = arith.constant 3 : index
13  ! CHECK:  %[[VAL_7:.*]] = fir.address_of(@_QFEmask1) : !fir.ref<!fir.array<3x!fir.logical<4>>>
14  ! CHECK:  %[[VAL_8:.*]] = arith.constant 3 : index
15  ! CHECK:  %[[VAL_9:.*]] = fir.address_of(@_QFEmask2) : !fir.ref<!fir.array<3x!fir.logical<4>>>
16  ! CHECK:  %[[VAL_10:.*]] = arith.constant 3 : index
17  ! CHECK:  %[[VAL_11:.*]] = arith.constant 0 : i32
18  ! CHECK:  %[[VAL_12:.*]] = arith.constant 0 : i64
19  ! CHECK:  %[[VAL_13:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_11]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<i64>
20  ! CHECK:  fir.store %[[VAL_12]] to %[[VAL_13]] : !fir.ref<i64>
21  ! CHECK:  %[[VAL_14:.*]] = arith.constant 1 : i32
22  ! CHECK:  %[[VAL_15:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi8>>
23  ! CHECK:  %[[VAL_16:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_14]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
24  ! CHECK:  fir.store %[[VAL_15]] to %[[VAL_16]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
25  ! CHECK:  %[[VAL_17:.*]] = arith.constant 2 : i32
26  ! CHECK:  %[[VAL_18:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi64>>
27  ! CHECK:  %[[VAL_19:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_17]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
28  ! CHECK:  fir.store %[[VAL_18]] to %[[VAL_19]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
29  ! CHECK:  %[[VAL_20:.*]] = arith.constant 0 : i32
30  ! CHECK:  %[[VAL_21:.*]] = arith.constant 0 : i64
31  ! CHECK:  %[[VAL_22:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_20]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<i64>
32  ! CHECK:  fir.store %[[VAL_21]] to %[[VAL_22]] : !fir.ref<i64>
33  ! CHECK:  %[[VAL_23:.*]] = arith.constant 1 : i32
34  ! CHECK:  %[[VAL_24:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi8>>
35  ! CHECK:  %[[VAL_25:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_23]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
36  ! CHECK:  fir.store %[[VAL_24]] to %[[VAL_25]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
37  ! CHECK:  %[[VAL_26:.*]] = arith.constant 2 : i32
38  ! CHECK:  %[[VAL_27:.*]] = fir.zero_bits !fir.heap<!fir.array<?xi64>>
39  ! CHECK:  %[[VAL_28:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_26]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
40  ! CHECK:  fir.store %[[VAL_27]] to %[[VAL_28]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
41  ! CHECK:  %[[VAL_29:.*]] = arith.constant 1 : i32
42  ! CHECK:  %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> index
43  ! CHECK:  %[[VAL_31:.*]] = arith.constant 3 : i32
44  ! CHECK:  %[[VAL_32:.*]] = fir.convert %[[VAL_31]] : (i32) -> index
45  ! CHECK:  %[[VAL_33:.*]] = arith.constant 1 : index
46  ! CHECK:  %[[VAL_34:.*]] = fir.shape %[[VAL_6]] : (index) -> !fir.shape<1>
47  ! CHECK:  %[[VAL_35:.*]] = fir.array_load %[[VAL_5]](%[[VAL_34]]) : (!fir.ref<!fir.array<3xi32>>, !fir.shape<1>) -> !fir.array<3xi32>
48  ! CHECK:  %[[VAL_36:.*]] = fir.do_loop %[[VAL_37:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_38:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) {
49  ! CHECK:    %[[VAL_39:.*]] = fir.convert %[[VAL_37]] : (index) -> i32
50  ! CHECK:    fir.store %[[VAL_39]] to %[[VAL_2]] : !fir.ref<i32>
51  ! CHECK:    %[[VAL_40:.*]] = arith.constant 1 : i64
52  ! CHECK:    %[[VAL_41:.*]] = arith.constant 0 : i64
53  ! CHECK:    %[[VAL_42:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
54  ! CHECK:    %[[VAL_43:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
55  ! CHECK:    %[[VAL_44:.*]] = fir.convert %[[VAL_33]] : (index) -> i64
56  ! CHECK:    %[[VAL_45:.*]] = arith.subi %[[VAL_43]], %[[VAL_42]] : i64
57  ! CHECK:    %[[VAL_46:.*]] = arith.addi %[[VAL_45]], %[[VAL_44]] : i64
58  ! CHECK:    %[[VAL_47:.*]] = arith.divsi %[[VAL_46]], %[[VAL_44]] : i64
59  ! CHECK:    %[[VAL_48:.*]] = arith.cmpi sgt, %[[VAL_47]], %[[VAL_41]] : i64
60  ! CHECK:    %[[VAL_49:.*]] = arith.select %[[VAL_48]], %[[VAL_47]], %[[VAL_41]] : i64
61  ! CHECK:    %[[VAL_50:.*]] = arith.constant 1 : i32
62  ! CHECK:    %[[VAL_51:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_50]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
63  ! CHECK:    %[[VAL_52:.*]] = fir.load %[[VAL_51]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
64  ! CHECK:    %[[VAL_53:.*]] = fir.convert %[[VAL_52]] : (!fir.heap<!fir.array<?xi8>>) -> i64
65  ! CHECK:    %[[VAL_54:.*]] = arith.constant 0 : i64
66  ! CHECK:    %[[VAL_55:.*]] = arith.cmpi eq, %[[VAL_53]], %[[VAL_54]] : i64
67  ! CHECK:    fir.if %[[VAL_55]] {
68  ! CHECK:      %[[VAL_56:.*]] = arith.constant true
69  ! CHECK:      %[[VAL_57:.*]] = arith.constant 1 : i64
70  ! CHECK:      %[[VAL_58:.*]] = fir.allocmem !fir.array<1xi64>
71  ! CHECK:      %[[VAL_59:.*]] = arith.constant 0 : i32
72  ! CHECK:      %[[VAL_60:.*]] = fir.coordinate_of %[[VAL_58]], %[[VAL_59]] : (!fir.heap<!fir.array<1xi64>>, i32) -> !fir.ref<i64>
73  ! CHECK:      fir.store %[[VAL_49]] to %[[VAL_60]] : !fir.ref<i64>
74  ! CHECK:      %[[VAL_61:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
75  ! CHECK:      %[[VAL_62:.*]] = fir.convert %[[VAL_58]] : (!fir.heap<!fir.array<1xi64>>) -> !fir.ref<i64>
76  ! CHECK:      %[[VAL_63:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_61]], %[[VAL_56]], %[[VAL_57]], %[[VAL_40]], %[[VAL_62]]) : (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
77  ! CHECK:    }
78  ! CHECK:    %[[VAL_64:.*]] = arith.subi %[[VAL_37]], %[[VAL_30]] : index
79  ! CHECK:    %[[VAL_65:.*]] = arith.divsi %[[VAL_64]], %[[VAL_33]] : index
80  ! CHECK:    %[[VAL_66:.*]] = arith.constant 1 : index
81  ! CHECK:    %[[VAL_67:.*]] = arith.addi %[[VAL_65]], %[[VAL_66]] : index
82  ! CHECK:    %[[VAL_68:.*]] = arith.constant 1 : i32
83  ! CHECK:    %[[VAL_69:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_68]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
84  ! CHECK:    %[[VAL_70:.*]] = fir.load %[[VAL_69]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
85  ! CHECK:    %[[VAL_71:.*]] = fir.convert %[[VAL_70]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
86  ! CHECK:    %[[VAL_72:.*]] = fir.shape %[[VAL_49]] : (i64) -> !fir.shape<1>
87  ! CHECK:    %[[VAL_73:.*]] = fir.array_coor %[[VAL_71]](%[[VAL_72]]) %[[VAL_67]] : (!fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<1>, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
88  ! CHECK:    %[[VAL_74:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1>
89  ! CHECK:    %[[VAL_75:.*]] = fir.array_load %[[VAL_7]](%[[VAL_74]]) : (!fir.ref<!fir.array<3x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<3x!fir.logical<4>>
90  ! CHECK:    %[[VAL_76:.*]] = arith.constant 1 : i32
91  ! CHECK:    %[[VAL_77:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_76]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
92  ! CHECK:    %[[VAL_78:.*]] = fir.load %[[VAL_77]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
93  ! CHECK:    %[[VAL_79:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1>
94  ! CHECK:    %[[VAL_80:.*]] = fir.array_load %[[VAL_78]](%[[VAL_79]]) : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>) -> !fir.array<?xi8>
95  ! CHECK:    %[[VAL_81:.*]] = arith.constant 1 : i64
96  ! CHECK:    %[[VAL_82:.*]] = arith.constant 1 : i32
97  ! CHECK:    %[[VAL_83:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_82]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
98  ! CHECK:    %[[VAL_84:.*]] = fir.load %[[VAL_83]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
99  ! CHECK:    %[[VAL_85:.*]] = fir.convert %[[VAL_84]] : (!fir.heap<!fir.array<?xi8>>) -> i64
100  ! CHECK:    %[[VAL_86:.*]] = arith.constant 0 : i64
101  ! CHECK:    %[[VAL_87:.*]] = arith.cmpi eq, %[[VAL_85]], %[[VAL_86]] : i64
102  ! CHECK:    fir.if %[[VAL_87]] {
103  ! CHECK:      %[[VAL_88:.*]] = arith.constant false
104  ! CHECK:      %[[VAL_89:.*]] = arith.constant 1 : i64
105  ! CHECK:      %[[VAL_90:.*]] = fir.allocmem !fir.array<1xi64>
106  ! CHECK:      %[[VAL_91:.*]] = arith.constant 0 : i32
107  ! CHECK:      %[[VAL_92:.*]] = fir.coordinate_of %[[VAL_90]], %[[VAL_91]] : (!fir.heap<!fir.array<1xi64>>, i32) -> !fir.ref<i64>
108  ! CHECK:      %[[VAL_93:.*]] = fir.convert %[[VAL_8]] : (index) -> i64
109  ! CHECK:      fir.store %[[VAL_93]] to %[[VAL_92]] : !fir.ref<i64>
110  ! CHECK:      %[[VAL_94:.*]] = fir.convert %[[VAL_73]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
111  ! CHECK:      %[[VAL_95:.*]] = fir.convert %[[VAL_90]] : (!fir.heap<!fir.array<1xi64>>) -> !fir.ref<i64>
112  ! CHECK:      %[[VAL_96:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_94]], %[[VAL_88]], %[[VAL_89]], %[[VAL_81]], %[[VAL_95]]) : (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
113  ! CHECK:    }
114  ! CHECK:    %[[VAL_97:.*]] = arith.constant 1 : index
115  ! CHECK:    %[[VAL_98:.*]] = arith.constant 0 : index
116  ! CHECK:    %[[VAL_99:.*]] = arith.subi %[[VAL_8]], %[[VAL_97]] : index
117  ! CHECK:    %[[VAL_100:.*]] = fir.do_loop %[[VAL_101:.*]] = %[[VAL_98]] to %[[VAL_99]] step %[[VAL_97]] unordered iter_args(%[[VAL_102:.*]] = %[[VAL_80]]) -> (!fir.array<?xi8>) {
118  ! CHECK:      %[[VAL_103:.*]] = fir.array_fetch %[[VAL_75]], %[[VAL_101]] : (!fir.array<3x!fir.logical<4>>, index) -> !fir.logical<4>
119  ! CHECK:      %[[VAL_104:.*]] = arith.constant 1 : i32
120  ! CHECK:      %[[VAL_105:.*]] = fir.coordinate_of %[[VAL_73]], %[[VAL_104]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
121  ! CHECK:      %[[VAL_106:.*]] = fir.load %[[VAL_105]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
122  ! CHECK:      %[[VAL_107:.*]] = fir.shape %[[VAL_8]] : (index) -> !fir.shape<1>
123  ! CHECK:      %[[VAL_108:.*]] = arith.constant 1 : index
124  ! CHECK:      %[[VAL_109:.*]] = arith.addi %[[VAL_101]], %[[VAL_108]] : index
125  ! CHECK:      %[[VAL_110:.*]] = fir.array_coor %[[VAL_106]](%[[VAL_107]]) %[[VAL_109]] : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
126  ! CHECK:      %[[VAL_111:.*]] = fir.convert %[[VAL_103]] : (!fir.logical<4>) -> i8
127  ! CHECK:      fir.store %[[VAL_111]] to %[[VAL_110]] : !fir.ref<i8>
128  ! CHECK:      fir.result %[[VAL_102]] : !fir.array<?xi8>
129  ! CHECK:    }
130  ! CHECK:    fir.result %[[VAL_38]] : !fir.array<3xi32>
131  ! CHECK:  }
132  ! CHECK:  %[[VAL_112:.*]] = fir.do_loop %[[VAL_113:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_114:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) {
133  ! CHECK:    %[[VAL_115:.*]] = fir.convert %[[VAL_113]] : (index) -> i32
134  ! CHECK:    fir.store %[[VAL_115]] to %[[VAL_1]] : !fir.ref<i32>
135  ! CHECK:    %[[VAL_116:.*]] = arith.constant 1 : i64
136  ! CHECK:    %[[VAL_117:.*]] = arith.constant 0 : i64
137  ! CHECK:    %[[VAL_118:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
138  ! CHECK:    %[[VAL_119:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
139  ! CHECK:    %[[VAL_120:.*]] = fir.convert %[[VAL_33]] : (index) -> i64
140  ! CHECK:    %[[VAL_121:.*]] = arith.subi %[[VAL_119]], %[[VAL_118]] : i64
141  ! CHECK:    %[[VAL_122:.*]] = arith.addi %[[VAL_121]], %[[VAL_120]] : i64
142  ! CHECK:    %[[VAL_123:.*]] = arith.divsi %[[VAL_122]], %[[VAL_120]] : i64
143  ! CHECK:    %[[VAL_124:.*]] = arith.cmpi sgt, %[[VAL_123]], %[[VAL_117]] : i64
144  ! CHECK:    %[[VAL_125:.*]] = arith.select %[[VAL_124]], %[[VAL_123]], %[[VAL_117]] : i64
145  ! CHECK:    %[[VAL_126:.*]] = arith.constant 1 : i32
146  ! CHECK:    %[[VAL_127:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_126]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
147  ! CHECK:    %[[VAL_128:.*]] = fir.load %[[VAL_127]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
148  ! CHECK:    %[[VAL_129:.*]] = fir.convert %[[VAL_128]] : (!fir.heap<!fir.array<?xi8>>) -> i64
149  ! CHECK:    %[[VAL_130:.*]] = arith.constant 0 : i64
150  ! CHECK:    %[[VAL_131:.*]] = arith.cmpi eq, %[[VAL_129]], %[[VAL_130]] : i64
151  ! CHECK:    fir.if %[[VAL_131]] {
152  ! CHECK:      %[[VAL_132:.*]] = arith.constant true
153  ! CHECK:      %[[VAL_133:.*]] = arith.constant 1 : i64
154  ! CHECK:      %[[VAL_134:.*]] = fir.allocmem !fir.array<1xi64>
155  ! CHECK:      %[[VAL_135:.*]] = arith.constant 0 : i32
156  ! CHECK:      %[[VAL_136:.*]] = fir.coordinate_of %[[VAL_134]], %[[VAL_135]] : (!fir.heap<!fir.array<1xi64>>, i32) -> !fir.ref<i64>
157  ! CHECK:      fir.store %[[VAL_125]] to %[[VAL_136]] : !fir.ref<i64>
158  ! CHECK:      %[[VAL_137:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
159  ! CHECK:      %[[VAL_138:.*]] = fir.convert %[[VAL_134]] : (!fir.heap<!fir.array<1xi64>>) -> !fir.ref<i64>
160  ! CHECK:      %[[VAL_139:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_137]], %[[VAL_132]], %[[VAL_133]], %[[VAL_116]], %[[VAL_138]]) : (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
161  ! CHECK:    }
162  ! CHECK:    %[[VAL_140:.*]] = arith.subi %[[VAL_113]], %[[VAL_30]] : index
163  ! CHECK:    %[[VAL_141:.*]] = arith.divsi %[[VAL_140]], %[[VAL_33]] : index
164  ! CHECK:    %[[VAL_142:.*]] = arith.constant 1 : index
165  ! CHECK:    %[[VAL_143:.*]] = arith.addi %[[VAL_141]], %[[VAL_142]] : index
166  ! CHECK:    %[[VAL_144:.*]] = arith.constant 1 : i32
167  ! CHECK:    %[[VAL_145:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_144]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
168  ! CHECK:    %[[VAL_146:.*]] = fir.load %[[VAL_145]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
169  ! CHECK:    %[[VAL_147:.*]] = fir.convert %[[VAL_146]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
170  ! CHECK:    %[[VAL_148:.*]] = fir.shape %[[VAL_125]] : (i64) -> !fir.shape<1>
171  ! CHECK:    %[[VAL_149:.*]] = fir.array_coor %[[VAL_147]](%[[VAL_148]]) %[[VAL_143]] : (!fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<1>, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
172  ! CHECK:    %[[VAL_150:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1>
173  ! CHECK:    %[[VAL_151:.*]] = fir.array_load %[[VAL_9]](%[[VAL_150]]) : (!fir.ref<!fir.array<3x!fir.logical<4>>>, !fir.shape<1>) -> !fir.array<3x!fir.logical<4>>
174  ! CHECK:    %[[VAL_152:.*]] = arith.constant 1 : i32
175  ! CHECK:    %[[VAL_153:.*]] = fir.coordinate_of %[[VAL_149]], %[[VAL_152]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
176  ! CHECK:    %[[VAL_154:.*]] = fir.load %[[VAL_153]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
177  ! CHECK:    %[[VAL_155:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1>
178  ! CHECK:    %[[VAL_156:.*]] = fir.array_load %[[VAL_154]](%[[VAL_155]]) : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>) -> !fir.array<?xi8>
179  ! CHECK:    %[[VAL_157:.*]] = arith.constant 1 : i64
180  ! CHECK:    %[[VAL_158:.*]] = arith.constant 1 : i32
181  ! CHECK:    %[[VAL_159:.*]] = fir.coordinate_of %[[VAL_149]], %[[VAL_158]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
182  ! CHECK:    %[[VAL_160:.*]] = fir.load %[[VAL_159]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
183  ! CHECK:    %[[VAL_161:.*]] = fir.convert %[[VAL_160]] : (!fir.heap<!fir.array<?xi8>>) -> i64
184  ! CHECK:    %[[VAL_162:.*]] = arith.constant 0 : i64
185  ! CHECK:    %[[VAL_163:.*]] = arith.cmpi eq, %[[VAL_161]], %[[VAL_162]] : i64
186  ! CHECK:    fir.if %[[VAL_163]] {
187  ! CHECK:      %[[VAL_164:.*]] = arith.constant false
188  ! CHECK:      %[[VAL_165:.*]] = arith.constant 1 : i64
189  ! CHECK:      %[[VAL_166:.*]] = fir.allocmem !fir.array<1xi64>
190  ! CHECK:      %[[VAL_167:.*]] = arith.constant 0 : i32
191  ! CHECK:      %[[VAL_168:.*]] = fir.coordinate_of %[[VAL_166]], %[[VAL_167]] : (!fir.heap<!fir.array<1xi64>>, i32) -> !fir.ref<i64>
192  ! CHECK:      %[[VAL_169:.*]] = fir.convert %[[VAL_10]] : (index) -> i64
193  ! CHECK:      fir.store %[[VAL_169]] to %[[VAL_168]] : !fir.ref<i64>
194  ! CHECK:      %[[VAL_170:.*]] = fir.convert %[[VAL_149]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
195  ! CHECK:      %[[VAL_171:.*]] = fir.convert %[[VAL_166]] : (!fir.heap<!fir.array<1xi64>>) -> !fir.ref<i64>
196  ! CHECK:      %[[VAL_172:.*]] = fir.call @_FortranARaggedArrayAllocate(%[[VAL_170]], %[[VAL_164]], %[[VAL_165]], %[[VAL_157]], %[[VAL_171]]) : (!fir.llvm_ptr<i8>, i1, i64, i64, !fir.ref<i64>) -> !fir.llvm_ptr<i8>
197  ! CHECK:    }
198  ! CHECK:    %[[VAL_173:.*]] = arith.constant 1 : index
199  ! CHECK:    %[[VAL_174:.*]] = arith.constant 0 : index
200  ! CHECK:    %[[VAL_175:.*]] = arith.subi %[[VAL_10]], %[[VAL_173]] : index
201  ! CHECK:    %[[VAL_176:.*]] = fir.do_loop %[[VAL_177:.*]] = %[[VAL_174]] to %[[VAL_175]] step %[[VAL_173]] unordered iter_args(%[[VAL_178:.*]] = %[[VAL_156]]) -> (!fir.array<?xi8>) {
202  ! CHECK:      %[[VAL_179:.*]] = fir.array_fetch %[[VAL_151]], %[[VAL_177]] : (!fir.array<3x!fir.logical<4>>, index) -> !fir.logical<4>
203  ! CHECK:      %[[VAL_180:.*]] = arith.constant 1 : i32
204  ! CHECK:      %[[VAL_181:.*]] = fir.coordinate_of %[[VAL_149]], %[[VAL_180]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
205  ! CHECK:      %[[VAL_182:.*]] = fir.load %[[VAL_181]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
206  ! CHECK:      %[[VAL_183:.*]] = fir.shape %[[VAL_10]] : (index) -> !fir.shape<1>
207  ! CHECK:      %[[VAL_184:.*]] = arith.constant 1 : index
208  ! CHECK:      %[[VAL_185:.*]] = arith.addi %[[VAL_177]], %[[VAL_184]] : index
209  ! CHECK:      %[[VAL_186:.*]] = fir.array_coor %[[VAL_182]](%[[VAL_183]]) %[[VAL_185]] : (!fir.heap<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
210  ! CHECK:      %[[VAL_187:.*]] = fir.convert %[[VAL_179]] : (!fir.logical<4>) -> i8
211  ! CHECK:      fir.store %[[VAL_187]] to %[[VAL_186]] : !fir.ref<i8>
212  ! CHECK:      fir.result %[[VAL_178]] : !fir.array<?xi8>
213  ! CHECK:    }
214  ! CHECK:    fir.result %[[VAL_114]] : !fir.array<3xi32>
215  ! CHECK:  }
216  ! CHECK:  %[[VAL_188:.*]] = fir.do_loop %[[VAL_189:.*]] = %[[VAL_30]] to %[[VAL_32]] step %[[VAL_33]] unordered iter_args(%[[VAL_190:.*]] = %[[VAL_35]]) -> (!fir.array<3xi32>) {
217  ! CHECK:    %[[VAL_191:.*]] = fir.convert %[[VAL_189]] : (index) -> i32
218  ! CHECK:    fir.store %[[VAL_191]] to %[[VAL_0]] : !fir.ref<i32>
219  ! CHECK:    %[[VAL_192:.*]] = arith.constant 0 : i64
220  ! CHECK:    %[[VAL_193:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
221  ! CHECK:    %[[VAL_194:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
222  ! CHECK:    %[[VAL_195:.*]] = fir.convert %[[VAL_33]] : (index) -> i64
223  ! CHECK:    %[[VAL_196:.*]] = arith.subi %[[VAL_194]], %[[VAL_193]] : i64
224  ! CHECK:    %[[VAL_197:.*]] = arith.addi %[[VAL_196]], %[[VAL_195]] : i64
225  ! CHECK:    %[[VAL_198:.*]] = arith.divsi %[[VAL_197]], %[[VAL_195]] : i64
226  ! CHECK:    %[[VAL_199:.*]] = arith.cmpi sgt, %[[VAL_198]], %[[VAL_192]] : i64
227  ! CHECK:    %[[VAL_200:.*]] = arith.select %[[VAL_199]], %[[VAL_198]], %[[VAL_192]] : i64
228  ! CHECK:    %[[VAL_201:.*]] = arith.subi %[[VAL_189]], %[[VAL_30]] : index
229  ! CHECK:    %[[VAL_202:.*]] = arith.divsi %[[VAL_201]], %[[VAL_33]] : index
230  ! CHECK:    %[[VAL_203:.*]] = arith.constant 1 : index
231  ! CHECK:    %[[VAL_204:.*]] = arith.addi %[[VAL_202]], %[[VAL_203]] : index
232  ! CHECK:    %[[VAL_205:.*]] = arith.constant 1 : i32
233  ! CHECK:    %[[VAL_206:.*]] = fir.coordinate_of %[[VAL_4]], %[[VAL_205]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
234  ! CHECK:    %[[VAL_207:.*]] = fir.load %[[VAL_206]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
235  ! CHECK:    %[[VAL_208:.*]] = fir.convert %[[VAL_207]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
236  ! CHECK:    %[[VAL_209:.*]] = fir.shape %[[VAL_200]] : (i64) -> !fir.shape<1>
237  ! CHECK:    %[[VAL_210:.*]] = fir.array_coor %[[VAL_208]](%[[VAL_209]]) %[[VAL_204]] : (!fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<1>, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
238  ! CHECK:    %[[VAL_211:.*]] = arith.constant 1 : i32
239  ! CHECK:    %[[VAL_212:.*]] = fir.coordinate_of %[[VAL_210]], %[[VAL_211]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
240  ! CHECK:    %[[VAL_213:.*]] = fir.load %[[VAL_212]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
241  ! CHECK:    %[[VAL_214:.*]] = fir.convert %[[VAL_213]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xi8>>
242  ! CHECK:    %[[VAL_215:.*]] = arith.constant 2 : i32
243  ! CHECK:    %[[VAL_216:.*]] = fir.coordinate_of %[[VAL_210]], %[[VAL_215]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
244  ! CHECK:    %[[VAL_217:.*]] = fir.load %[[VAL_216]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
245  ! CHECK:    %[[VAL_218:.*]] = arith.constant 0 : i32
246  ! CHECK:    %[[VAL_219:.*]] = fir.coordinate_of %[[VAL_217]], %[[VAL_218]] : (!fir.heap<!fir.array<?xi64>>, i32) -> !fir.ref<i64>
247  ! CHECK:    %[[VAL_220:.*]] = fir.load %[[VAL_219]] : !fir.ref<i64>
248  ! CHECK:    %[[VAL_221:.*]] = fir.convert %[[VAL_220]] : (i64) -> index
249  ! CHECK:    %[[VAL_222:.*]] = fir.shape %[[VAL_221]] : (index) -> !fir.shape<1>
250  ! CHECK:    %[[VAL_223:.*]] = arith.constant 0 : i64
251  ! CHECK:    %[[VAL_224:.*]] = fir.convert %[[VAL_30]] : (index) -> i64
252  ! CHECK:    %[[VAL_225:.*]] = fir.convert %[[VAL_32]] : (index) -> i64
253  ! CHECK:    %[[VAL_226:.*]] = fir.convert %[[VAL_33]] : (index) -> i64
254  ! CHECK:    %[[VAL_227:.*]] = arith.subi %[[VAL_225]], %[[VAL_224]] : i64
255  ! CHECK:    %[[VAL_228:.*]] = arith.addi %[[VAL_227]], %[[VAL_226]] : i64
256  ! CHECK:    %[[VAL_229:.*]] = arith.divsi %[[VAL_228]], %[[VAL_226]] : i64
257  ! CHECK:    %[[VAL_230:.*]] = arith.cmpi sgt, %[[VAL_229]], %[[VAL_223]] : i64
258  ! CHECK:    %[[VAL_231:.*]] = arith.select %[[VAL_230]], %[[VAL_229]], %[[VAL_223]] : i64
259  ! CHECK:    %[[VAL_232:.*]] = arith.subi %[[VAL_189]], %[[VAL_30]] : index
260  ! CHECK:    %[[VAL_233:.*]] = arith.divsi %[[VAL_232]], %[[VAL_33]] : index
261  ! CHECK:    %[[VAL_234:.*]] = arith.constant 1 : index
262  ! CHECK:    %[[VAL_235:.*]] = arith.addi %[[VAL_233]], %[[VAL_234]] : index
263  ! CHECK:    %[[VAL_236:.*]] = arith.constant 1 : i32
264  ! CHECK:    %[[VAL_237:.*]] = fir.coordinate_of %[[VAL_3]], %[[VAL_236]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
265  ! CHECK:    %[[VAL_238:.*]] = fir.load %[[VAL_237]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
266  ! CHECK:    %[[VAL_239:.*]] = fir.convert %[[VAL_238]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>
267  ! CHECK:    %[[VAL_240:.*]] = fir.shape %[[VAL_231]] : (i64) -> !fir.shape<1>
268  ! CHECK:    %[[VAL_241:.*]] = fir.array_coor %[[VAL_239]](%[[VAL_240]]) %[[VAL_235]] : (!fir.ref<!fir.array<?xtuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>>, !fir.shape<1>, index) -> !fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>
269  ! CHECK:    %[[VAL_242:.*]] = arith.constant 1 : i32
270  ! CHECK:    %[[VAL_243:.*]] = fir.coordinate_of %[[VAL_241]], %[[VAL_242]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi8>>>
271  ! CHECK:    %[[VAL_244:.*]] = fir.load %[[VAL_243]] : !fir.ref<!fir.heap<!fir.array<?xi8>>>
272  ! CHECK:    %[[VAL_245:.*]] = fir.convert %[[VAL_244]] : (!fir.heap<!fir.array<?xi8>>) -> !fir.ref<!fir.array<?xi8>>
273  ! CHECK:    %[[VAL_246:.*]] = arith.constant 2 : i32
274  ! CHECK:    %[[VAL_247:.*]] = fir.coordinate_of %[[VAL_241]], %[[VAL_246]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>, i32) -> !fir.ref<!fir.heap<!fir.array<?xi64>>>
275  ! CHECK:    %[[VAL_248:.*]] = fir.load %[[VAL_247]] : !fir.ref<!fir.heap<!fir.array<?xi64>>>
276  ! CHECK:    %[[VAL_249:.*]] = arith.constant 0 : i32
277  ! CHECK:    %[[VAL_250:.*]] = fir.coordinate_of %[[VAL_248]], %[[VAL_249]] : (!fir.heap<!fir.array<?xi64>>, i32) -> !fir.ref<i64>
278  ! CHECK:    %[[VAL_251:.*]] = fir.load %[[VAL_250]] : !fir.ref<i64>
279  ! CHECK:    %[[VAL_252:.*]] = fir.convert %[[VAL_251]] : (i64) -> index
280  ! CHECK:    %[[VAL_253:.*]] = fir.shape %[[VAL_252]] : (index) -> !fir.shape<1>
281  ! CHECK:    %[[VAL_254:.*]] = arith.constant 1 : i32
282  ! CHECK:    %[[VAL_255:.*]] = arith.constant 1 : index
283  ! CHECK:    %[[VAL_256:.*]] = arith.constant 0 : index
284  ! CHECK:    %[[VAL_257:.*]] = arith.subi %[[VAL_221]], %[[VAL_255]] : index
285  ! CHECK:    %[[VAL_258:.*]] = fir.do_loop %[[VAL_259:.*]] = %[[VAL_256]] to %[[VAL_257]] step %[[VAL_255]] unordered iter_args(%[[VAL_260:.*]] = %[[VAL_190]]) -> (!fir.array<3xi32>) {
286  ! CHECK:      %[[VAL_261:.*]] = arith.constant 1 : index
287  ! CHECK:      %[[VAL_262:.*]] = arith.addi %[[VAL_259]], %[[VAL_261]] : index
288  ! CHECK:      %[[VAL_263:.*]] = fir.array_coor %[[VAL_214]](%[[VAL_222]]) %[[VAL_262]] : (!fir.ref<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
289  ! CHECK:      %[[VAL_264:.*]] = fir.load %[[VAL_263]] : !fir.ref<i8>
290  ! CHECK:      %[[VAL_265:.*]] = fir.convert %[[VAL_264]] : (i8) -> i1
291  ! CHECK:      %[[VAL_266:.*]] = fir.if %[[VAL_265]] -> (!fir.array<3xi32>) {
292  ! CHECK:        %[[VAL_267:.*]] = arith.constant 1 : index
293  ! CHECK:        %[[VAL_268:.*]] = arith.addi %[[VAL_259]], %[[VAL_267]] : index
294  ! CHECK:        %[[VAL_269:.*]] = fir.array_coor %[[VAL_245]](%[[VAL_253]]) %[[VAL_268]] : (!fir.ref<!fir.array<?xi8>>, !fir.shape<1>, index) -> !fir.ref<i8>
295  ! CHECK:        %[[VAL_270:.*]] = fir.load %[[VAL_269]] : !fir.ref<i8>
296  ! CHECK:        %[[VAL_271:.*]] = fir.convert %[[VAL_270]] : (i8) -> i1
297  ! CHECK:        %[[VAL_272:.*]] = fir.if %[[VAL_271]] -> (!fir.array<3xi32>) {
298  ! CHECK:          %[[VAL_273:.*]] = fir.array_update %[[VAL_260]], %[[VAL_254]], %[[VAL_259]] : (!fir.array<3xi32>, i32, index) -> !fir.array<3xi32>
299  ! CHECK:          fir.result %[[VAL_273]] : !fir.array<3xi32>
300  ! CHECK:        } else {
301  ! CHECK:          fir.result %[[VAL_260]] : !fir.array<3xi32>
302  ! CHECK:        }
303  ! CHECK:        fir.result %[[VAL_274:.*]] : !fir.array<3xi32>
304  ! CHECK:      } else {
305  ! CHECK:        fir.result %[[VAL_260]] : !fir.array<3xi32>
306  ! CHECK:      }
307  ! CHECK:      fir.result %[[VAL_275:.*]] : !fir.array<3xi32>
308  ! CHECK:    }
309  ! CHECK:    fir.result %[[VAL_276:.*]] : !fir.array<3xi32>
310  ! CHECK:  }
311  ! CHECK:  fir.array_merge_store %[[VAL_35]], %[[VAL_277:.*]] to %[[VAL_5]] : !fir.array<3xi32>, !fir.array<3xi32>, !fir.ref<!fir.array<3xi32>>
312  ! CHECK:  %[[VAL_278:.*]] = fir.convert %[[VAL_3]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
313  ! CHECK:  %[[VAL_279:.*]] = fir.call @_FortranARaggedArrayDeallocate(%[[VAL_278]]) : (!fir.llvm_ptr<i8>) -> none
314  ! CHECK:  %[[VAL_280:.*]] = fir.convert %[[VAL_4]] : (!fir.ref<tuple<i64, !fir.heap<!fir.array<?xi8>>, !fir.heap<!fir.array<?xi64>>>>) -> !fir.llvm_ptr<i8>
315  ! CHECK:  %[[VAL_281:.*]] = fir.call @_FortranARaggedArrayDeallocate(%[[VAL_280]]) : (!fir.llvm_ptr<i8>) -> none
316
317  integer :: a(3) = 0
318  logical :: mask1(3) = (/ .true.,.false.,.true. /)
319  logical :: mask2(3) = (/ .true.,.true.,.false. /)
320  forall (i=1:3)
321    where (mask1)
322      where (mask2)
323        a = 1
324      end where
325    endwhere
326  end forall
327  ! CHECK:  return
328  ! CHECK: }
329end program nested_where
330