1! Test lowering of elemental calls with character argument
2! without the VALUE attribute.
3! RUN: bbc -o - %s | FileCheck %s
4
5module char_elem
6
7interface
8elemental integer function elem(c)
9  character(*), intent(in) :: c
10end function
11
12elemental integer function elem2(c, j)
13  character(*), intent(in) :: c
14  integer, intent(in) :: j
15end function
16
17end interface
18
19contains
20
21! CHECK-LABEL: func @_QMchar_elemPfoo1(
22! CHECK-SAME: %[[VAL_15:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_4:.*]]: !fir.boxchar<1>{{.*}}) {
23subroutine foo1(i, c)
24  integer :: i(10)
25  character(*) :: c(10)
26! CHECK-DAG:   %[[VAL_0:.*]] = arith.constant 10 : index
27! CHECK-DAG:   %[[VAL_1:.*]] = arith.constant 0 : index
28! CHECK-DAG:   %[[VAL_2:.*]] = arith.constant 1 : index
29! CHECK:   %[[VAL_3:.*]]:2 = fir.unboxchar %[[VAL_4]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
30! CHECK:   %[[VAL_5:.*]] = fir.convert %[[VAL_3]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,?>>>
31! CHECK:   %[[VAL_6:.*]] = fir.shape %[[VAL_0]] : (index) -> !fir.shape<1>
32! CHECK:   br ^bb1(%[[VAL_1]], %[[VAL_0]] : index, index)
33! CHECK: ^bb1(%[[VAL_7:.*]]: index, %[[VAL_8:.*]]: index):
34! CHECK:   %[[VAL_9:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_1]] : index
35! CHECK:   cond_br %[[VAL_9]], ^bb2, ^bb3
36! CHECK: ^bb2:
37! CHECK:   %[[VAL_10:.*]] = arith.addi %[[VAL_7]], %[[VAL_2]] : index
38! CHECK:   %[[VAL_11:.*]] = fir.array_coor %[[VAL_5]](%[[VAL_6]]) %[[VAL_10]] typeparams %[[VAL_3]]#1 : (!fir.ref<!fir.array<10x!fir.char<1,?>>>, !fir.shape<1>, index, index) -> !fir.ref<!fir.char<1,?>>
39! CHECK:   %[[VAL_12:.*]] = fir.emboxchar %[[VAL_11]], %[[VAL_3]]#1 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
40! CHECK:   %[[VAL_13:.*]] = fir.call @_QPelem(%[[VAL_12]]) : (!fir.boxchar<1>) -> i32
41! CHECK:   %[[VAL_14:.*]] = fir.array_coor %[[VAL_15]](%[[VAL_6]]) %[[VAL_10]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
42! CHECK:   fir.store %[[VAL_13]] to %[[VAL_14]] : !fir.ref<i32>
43! CHECK:   %[[VAL_16:.*]] = arith.subi %[[VAL_8]], %[[VAL_2]] : index
44! CHECK:   br ^bb1(%[[VAL_10]], %[[VAL_16]] : index, index)
45! CHECK: ^bb3:
46! CHECK:   return
47  i = elem(c)
48end subroutine
49
50! CHECK-LABEL: func @_QMchar_elemPfoo1b(
51! CHECK-SAME: %[[VAL_33:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_21:.*]]: !fir.boxchar<1>{{.*}}) {
52subroutine foo1b(i, c)
53  integer :: i(10)
54  character(10) :: c(10)
55! CHECK-DAG:   %[[VAL_17:.*]] = arith.constant 10 : index
56! CHECK-DAG:   %[[VAL_18:.*]] = arith.constant 0 : index
57! CHECK-DAG:   %[[VAL_19:.*]] = arith.constant 1 : index
58! CHECK:   %[[VAL_20:.*]]:2 = fir.unboxchar %[[VAL_21]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
59! CHECK:   %[[VAL_22:.*]] = fir.convert %[[VAL_20]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,10>>>
60! CHECK:   %[[VAL_23:.*]] = fir.shape %[[VAL_17]] : (index) -> !fir.shape<1>
61! CHECK:   br ^bb1(%[[VAL_18]], %[[VAL_17]] : index, index)
62! CHECK: ^bb1(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index):
63! CHECK:   %[[VAL_26:.*]] = arith.cmpi sgt, %[[VAL_25]], %[[VAL_18]] : index
64! CHECK:   cond_br %[[VAL_26]], ^bb2, ^bb3
65! CHECK: ^bb2:
66! CHECK:   %[[VAL_27:.*]] = arith.addi %[[VAL_24]], %[[VAL_19]] : index
67! CHECK:   %[[VAL_28:.*]] = fir.array_coor %[[VAL_22]](%[[VAL_23]]) %[[VAL_27]] : (!fir.ref<!fir.array<10x!fir.char<1,10>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,10>>
68! CHECK:   %[[VAL_29:.*]] = fir.convert %[[VAL_28]] : (!fir.ref<!fir.char<1,10>>) -> !fir.ref<!fir.char<1,?>>
69! CHECK:   %[[VAL_30:.*]] = fir.emboxchar %[[VAL_29]], %[[VAL_17]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
70! CHECK:   %[[VAL_31:.*]] = fir.call @_QPelem(%[[VAL_30]]) : (!fir.boxchar<1>) -> i32
71! CHECK:   %[[VAL_32:.*]] = fir.array_coor %[[VAL_33]](%[[VAL_23]]) %[[VAL_27]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
72! CHECK:   fir.store %[[VAL_31]] to %[[VAL_32]] : !fir.ref<i32>
73! CHECK:   %[[VAL_34:.*]] = arith.subi %[[VAL_25]], %[[VAL_19]] : index
74! CHECK:   br ^bb1(%[[VAL_27]], %[[VAL_34]] : index, index)
75! CHECK: ^bb3:
76! CHECK:   return
77  i = elem(c)
78end subroutine
79
80! CHECK-LABEL: func @_QMchar_elemPfoo2(
81! CHECK-SAME: %[[VAL_50:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_47:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_39:.*]]: !fir.boxchar<1>{{.*}}) {
82subroutine foo2(i, j, c)
83! CHECK-DAG:   %[[VAL_35:.*]] = arith.constant 10 : index
84! CHECK-DAG:   %[[VAL_36:.*]] = arith.constant 0 : index
85! CHECK-DAG:   %[[VAL_37:.*]] = arith.constant 1 : index
86! CHECK:   %[[VAL_38:.*]]:2 = fir.unboxchar %[[VAL_39]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
87! CHECK:   %[[VAL_40:.*]] = fir.shape %[[VAL_35]] : (index) -> !fir.shape<1>
88! CHECK:   br ^bb1(%[[VAL_36]], %[[VAL_35]] : index, index)
89! CHECK: ^bb1(%[[VAL_41:.*]]: index, %[[VAL_42:.*]]: index):
90! CHECK:   %[[VAL_43:.*]] = arith.cmpi sgt, %[[VAL_42]], %[[VAL_36]] : index
91! CHECK:   cond_br %[[VAL_43]], ^bb2, ^bb3
92! CHECK: ^bb2:
93! CHECK:   %[[VAL_44:.*]] = fir.emboxchar %[[VAL_38]]#0, %[[VAL_38]]#1 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
94! CHECK:   %[[VAL_45:.*]] = arith.addi %[[VAL_41]], %[[VAL_37]] : index
95! CHECK:   %[[VAL_46:.*]] = fir.array_coor %[[VAL_47]](%[[VAL_40]]) %[[VAL_45]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
96! CHECK:   %[[VAL_48:.*]] = fir.call @_QPelem2(%[[VAL_44]], %[[VAL_46]]) : (!fir.boxchar<1>, !fir.ref<i32>) -> i32
97! CHECK:   %[[VAL_49:.*]] = fir.array_coor %[[VAL_50]](%[[VAL_40]]) %[[VAL_45]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
98! CHECK:   fir.store %[[VAL_48]] to %[[VAL_49]] : !fir.ref<i32>
99! CHECK:   %[[VAL_51:.*]] = arith.subi %[[VAL_42]], %[[VAL_37]] : index
100! CHECK:   br ^bb1(%[[VAL_45]], %[[VAL_51]] : index, index)
101! CHECK: ^bb3:
102! CHECK:   return
103  integer :: i(10), j(10)
104  character(*) :: c
105  i = elem2(c, j)
106end subroutine
107
108! CHECK-LABEL: func @_QMchar_elemPfoo2b(
109! CHECK-SAME: %[[VAL_67:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_64:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_56:.*]]: !fir.boxchar<1>{{.*}}) {
110subroutine foo2b(i, j, c)
111  integer :: i(10), j(10)
112  character(10) :: c
113! CHECK-DAG:   %[[VAL_52:.*]] = arith.constant 10 : index
114! CHECK-DAG:   %[[VAL_53:.*]] = arith.constant 0 : index
115! CHECK-DAG:   %[[VAL_54:.*]] = arith.constant 1 : index
116! CHECK:   %[[VAL_55:.*]]:2 = fir.unboxchar %[[VAL_56]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
117! CHECK:   %[[VAL_57:.*]] = fir.shape %[[VAL_52]] : (index) -> !fir.shape<1>
118! CHECK:   br ^bb1(%[[VAL_53]], %[[VAL_52]] : index, index)
119! CHECK: ^bb1(%[[VAL_58:.*]]: index, %[[VAL_59:.*]]: index):
120! CHECK:   %[[VAL_60:.*]] = arith.cmpi sgt, %[[VAL_59]], %[[VAL_53]] : index
121! CHECK:   cond_br %[[VAL_60]], ^bb2, ^bb3
122! CHECK: ^bb2:
123! CHECK:   %[[VAL_61:.*]] = fir.emboxchar %[[VAL_55]]#0, %[[VAL_52]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
124! CHECK:   %[[VAL_62:.*]] = arith.addi %[[VAL_58]], %[[VAL_54]] : index
125! CHECK:   %[[VAL_63:.*]] = fir.array_coor %[[VAL_64]](%[[VAL_57]]) %[[VAL_62]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
126! CHECK:   %[[VAL_65:.*]] = fir.call @_QPelem2(%[[VAL_61]], %[[VAL_63]]) : (!fir.boxchar<1>, !fir.ref<i32>) -> i32
127! CHECK:   %[[VAL_66:.*]] = fir.array_coor %[[VAL_67]](%[[VAL_57]]) %[[VAL_62]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
128! CHECK:   fir.store %[[VAL_65]] to %[[VAL_66]] : !fir.ref<i32>
129! CHECK:   %[[VAL_68:.*]] = arith.subi %[[VAL_59]], %[[VAL_54]] : index
130! CHECK:   br ^bb1(%[[VAL_62]], %[[VAL_68]] : index, index)
131! CHECK: ^bb3:
132! CHECK:   return
133  i = elem2(c, j)
134end subroutine
135
136! CHECK-LABEL: func @_QMchar_elemPfoo3(
137! CHECK-SAME: %[[VAL_88:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_79:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}})
138subroutine foo3(i, j)
139  integer :: i(10), j(10)
140! CHECK-DAG:   %[[VAL_69:.*]] = arith.constant 10 : index
141! CHECK-DAG:   %[[VAL_70:.*]] = arith.constant 0 : index
142! CHECK-DAG:   %[[VAL_71:.*]] = arith.constant 1 : index
143! CHECK-DAG:   %[[VAL_72:.*]] = fir.alloca !fir.char<1>
144! CHECK:   %[[VAL_73:.*]] = fir.shape %[[VAL_69]] : (index) -> !fir.shape<1>
145! CHECK:   br ^bb1(%[[VAL_70]], %[[VAL_69]] : index, index)
146! CHECK: ^bb1(%[[VAL_74:.*]]: index, %[[VAL_75:.*]]: index):
147! CHECK:   %[[VAL_76:.*]] = arith.cmpi sgt, %[[VAL_75]], %[[VAL_70]] : index
148! CHECK:   cond_br %[[VAL_76]], ^bb2, ^bb3
149! CHECK: ^bb2:
150! CHECK:   %[[VAL_77:.*]] = arith.addi %[[VAL_74]], %[[VAL_71]] : index
151! CHECK:   %[[VAL_78:.*]] = fir.array_coor %[[VAL_79]](%[[VAL_73]]) %[[VAL_77]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
152! CHECK:   %[[VAL_80:.*]] = fir.load %[[VAL_78]] : !fir.ref<i32>
153! CHECK:   %[[VAL_81:.*]] = fir.convert %[[VAL_80]] : (i32) -> i8
154! CHECK:   %[[VAL_82:.*]] = fir.undefined !fir.char<1>
155! CHECK:   %[[VAL_83:.*]] = fir.insert_value %[[VAL_82]], %[[VAL_81]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
156! CHECK:   fir.store %[[VAL_83]] to %[[VAL_72]] : !fir.ref<!fir.char<1>>
157! CHECK:   %[[VAL_84:.*]] = fir.convert %[[VAL_72]] : (!fir.ref<!fir.char<1>>) -> !fir.ref<!fir.char<1,?>>
158! CHECK:   %[[VAL_85:.*]] = fir.emboxchar %[[VAL_84]], %[[VAL_71]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
159! CHECK:   %[[VAL_86:.*]] = fir.call @_QPelem(%[[VAL_85]]) : (!fir.boxchar<1>) -> i32
160! CHECK:   %[[VAL_87:.*]] = fir.array_coor %[[VAL_88]](%[[VAL_73]]) %[[VAL_77]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
161! CHECK:   fir.store %[[VAL_86]] to %[[VAL_87]] : !fir.ref<i32>
162! CHECK:   %[[VAL_89:.*]] = arith.subi %[[VAL_75]], %[[VAL_71]] : index
163! CHECK:   br ^bb1(%[[VAL_77]], %[[VAL_89]] : index, index)
164! CHECK: ^bb3:
165! CHECK:   return
166  i = elem(char(j))
167end subroutine
168
169! CHECK-LABEL: func @_QMchar_elemPfoo4(
170! CHECK-SAME: %[[VAL_106:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[VAL_103:[^:]+]]: !fir.ref<!fir.array<10xi32>>{{.*}})
171subroutine foo4(i, j)
172  integer :: i(10), j(10)
173! CHECK-DAG:   %[[VAL_90:.*]] = arith.constant 5 : index
174! CHECK-DAG:   %[[VAL_91:.*]] = arith.constant 10 : index
175! CHECK-DAG:   %[[VAL_92:.*]] = arith.constant 0 : index
176! CHECK-DAG:   %[[VAL_93:.*]] = arith.constant 1 : index
177! CHECK:   %[[VAL_94:.*]] = fir.shape %[[VAL_91]] : (index) -> !fir.shape<1>
178! CHECK:   %[[VAL_95:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,5>>
179! CHECK:   br ^bb1(%[[VAL_92]], %[[VAL_91]] : index, index)
180! CHECK: ^bb1(%[[VAL_96:.*]]: index, %[[VAL_97:.*]]: index):
181! CHECK:   %[[VAL_98:.*]] = arith.cmpi sgt, %[[VAL_97]], %[[VAL_92]] : index
182! CHECK:   cond_br %[[VAL_98]], ^bb2, ^bb3
183! CHECK: ^bb2:
184! CHECK:   %[[VAL_99:.*]] = fir.convert %[[VAL_95]] : (!fir.ref<!fir.char<1,5>>) -> !fir.ref<!fir.char<1,?>>
185! CHECK:   %[[VAL_100:.*]] = fir.emboxchar %[[VAL_99]], %[[VAL_90]] : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
186! CHECK:   %[[VAL_101:.*]] = arith.addi %[[VAL_96]], %[[VAL_93]] : index
187! CHECK:   %[[VAL_102:.*]] = fir.array_coor %[[VAL_103]](%[[VAL_94]]) %[[VAL_101]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
188! CHECK:   %[[VAL_104:.*]] = fir.call @_QPelem2(%[[VAL_100]], %[[VAL_102]]) : (!fir.boxchar<1>, !fir.ref<i32>) -> i32
189! CHECK:   %[[VAL_105:.*]] = fir.array_coor %[[VAL_106]](%[[VAL_94]]) %[[VAL_101]] : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>, index) -> !fir.ref<i32>
190! CHECK:   fir.store %[[VAL_104]] to %[[VAL_105]] : !fir.ref<i32>
191! CHECK:   %[[VAL_107:.*]] = arith.subi %[[VAL_97]], %[[VAL_93]] : index
192! CHECK:   br ^bb1(%[[VAL_101]], %[[VAL_107]] : index, index)
193! CHECK: ^bb3:
194! CHECK:   return
195  i = elem2("hello", j)
196end subroutine
197
198! Test character return for elemental functions.
199
200! CHECK-LABEL: func @_QMchar_elemPelem_return_char(
201! CHECK-SAME: %{{.*}}: !fir.ref<!fir.char<1,?>>{{.*}}, %{{.*}}: index{{.*}}, %{{.*}}: !fir.boxchar<1>{{.*}}) -> !fir.boxchar<1>
202elemental function elem_return_char(c)
203 character(*), intent(in) :: c
204 character(len(c)) :: elem_return_char
205 elem_return_char = "ab" // c
206end function
207
208! CHECK-LABEL: func @_QMchar_elemPfoo6(
209! CHECK-SAME:         %[[VAL_0:.*]]: !fir.boxchar<1> {fir.bindc_name = "c"}) {
210subroutine foo6(c)
211  ! CHECK-DAG:     %[[VAL_1:.*]] = arith.constant 10 : index
212  ! CHECK-DAG:     %[[VAL_2:.*]] = arith.constant 1 : index
213  ! CHECK-DAG:     %[[VAL_3:.*]] = arith.constant 0 : index
214  ! CHECK-DAG:     %[[VAL_4:.*]] = arith.constant false
215  ! CHECK-DAG:     %[[VAL_5:.*]] = arith.constant 32 : i8
216  ! CHECK:         %[[VAL_6:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
217  ! CHECK:         %[[VAL_7:.*]] = fir.convert %[[VAL_6]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<10x!fir.char<1,?>>>
218  ! CHECK:         %[[VAL_8:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
219  ! CHECK:         br ^bb1(%[[VAL_3]], %[[VAL_1]] : index, index)
220  ! CHECK:       ^bb1(%[[VAL_9:.*]]: index, %[[VAL_10:.*]]: index):
221  ! CHECK:         %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_10]], %[[VAL_3]] : index
222  ! CHECK:         cond_br %[[VAL_11]], ^bb2, ^bb6
223  ! CHECK:       ^bb2:
224  ! CHECK:         %[[VAL_12:.*]] = arith.addi %[[VAL_9]], %[[VAL_2]] : index
225  ! CHECK:         %[[VAL_13:.*]] = fir.array_coor %[[VAL_7]](%[[VAL_8]]) %[[VAL_12]] typeparams %[[VAL_6]]#1 : (!fir.ref<!fir.array<10x!fir.char<1,?>>>, !fir.shape<1>, index, index) -> !fir.ref<!fir.char<1,?>>
226  ! CHECK:         %[[VAL_14:.*]] = fir.emboxchar %[[VAL_13]], %[[VAL_6]]#1 : (!fir.ref<!fir.char<1,?>>, index) -> !fir.boxchar<1>
227  ! CHECK:         %[[VAL_15:.*]] = fir.convert %[[VAL_6]]#1 : (index) -> i32
228  ! CHECK:         %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i32) -> index
229  ! CHECK:         %[[VAL_17:.*]] = fir.call @llvm.stacksave() : () -> !fir.ref<i8>
230  ! CHECK:         %[[VAL_18:.*]] = fir.alloca !fir.char<1,?>(%[[VAL_16]] : index) {bindc_name = ".result"}
231  ! CHECK:         %[[VAL_19:.*]] = fir.call @_QMchar_elemPelem_return_char(%[[VAL_18]], %[[VAL_16]], %[[VAL_14]]) : (!fir.ref<!fir.char<1,?>>, index, !fir.boxchar<1>) -> !fir.boxchar<1>
232  ! CHECK:         %[[VAL_20:.*]] = arith.cmpi slt, %[[VAL_6]]#1, %[[VAL_16]] : index
233  ! CHECK:         %[[VAL_21:.*]] = arith.select %[[VAL_20]], %[[VAL_6]]#1, %[[VAL_16]] : index
234  ! CHECK:         %[[VAL_22:.*]] = fir.convert %[[VAL_21]] : (index) -> i64
235  ! CHECK:         %[[VAL_23:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
236  ! CHECK:         %[[VAL_24:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
237  ! CHECK:         fir.call @llvm.memmove.p0.p0.i64(%[[VAL_23]], %[[VAL_24]], %[[VAL_22]], %[[VAL_4]]) : (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
238  ! CHECK:         %[[VAL_25:.*]] = arith.subi %[[VAL_6]]#1, %[[VAL_2]] : index
239  ! CHECK:         %[[VAL_26:.*]] = fir.undefined !fir.char<1>
240  ! CHECK:         %[[VAL_27:.*]] = fir.insert_value %[[VAL_26]], %[[VAL_5]], [0 : index] : (!fir.char<1>, i8) -> !fir.char<1>
241  ! CHECK:         %[[VAL_28:.*]] = arith.subi %[[VAL_25]], %[[VAL_21]] : index
242  ! CHECK:         %[[VAL_29:.*]] = arith.addi %[[VAL_28]], %[[VAL_2]] : index
243  ! CHECK:         br ^bb3(%[[VAL_21]], %[[VAL_29]] : index, index)
244  ! CHECK:       ^bb3(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index):
245  ! CHECK:         %[[VAL_32:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_3]] : index
246  ! CHECK:         cond_br %[[VAL_32]], ^bb4, ^bb5
247  ! CHECK:       ^bb4:
248  ! CHECK:         %[[VAL_33:.*]] = fir.convert %[[VAL_13]] : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<?x!fir.char<1>>>
249  ! CHECK:         %[[VAL_34:.*]] = fir.coordinate_of %[[VAL_33]], %[[VAL_30]] : (!fir.ref<!fir.array<?x!fir.char<1>>>, index) -> !fir.ref<!fir.char<1>>
250  ! CHECK:         fir.store %[[VAL_27]] to %[[VAL_34]] : !fir.ref<!fir.char<1>>
251  ! CHECK:         %[[VAL_35:.*]] = arith.addi %[[VAL_30]], %[[VAL_2]] : index
252  ! CHECK:         %[[VAL_36:.*]] = arith.subi %[[VAL_31]], %[[VAL_2]] : index
253  ! CHECK:         br ^bb3(%[[VAL_35]], %[[VAL_36]] : index, index)
254  ! CHECK:       ^bb5:
255  ! CHECK:         fir.call @llvm.stackrestore(%[[VAL_17]]) : (!fir.ref<i8>) -> ()
256  ! CHECK:         %[[VAL_37:.*]] = arith.subi %[[VAL_10]], %[[VAL_2]] : index
257  ! CHECK:         br ^bb1(%[[VAL_12]], %[[VAL_37]] : index, index)
258  ! CHECK:       ^bb6:
259
260  implicit none
261  character(*) :: c(10)
262  c = elem_return_char(c)
263  ! CHECK: return
264  ! CHECK: }
265end subroutine
266
267end module
268