• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1; RUN: llc < %s -mtriple=armv7-apple-ios -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-IOS --check-prefix=CHECK
2; RUN: llc < %s -mtriple=thumbv7m-none-macho -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-DARWIN --check-prefix=CHECK
3; RUN: llc < %s -mtriple=arm-none-eabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
4; RUN: llc < %s -mtriple=arm-none-eabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
5; RUN: llc < %s -mtriple=arm-none-androideabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-EABI --check-prefix=CHECK
6; RUN: llc < %s -mtriple=arm-none-gnueabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
7; RUN: llc < %s -mtriple=arm-none-gnueabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
8; RUN: llc < %s -mtriple=arm-none-musleabi -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
9; RUN: llc < %s -mtriple=arm-none-musleabihf -disable-post-ra -o - | FileCheck %s --check-prefix=CHECK-GNUEABI --check-prefix=CHECK
10
11define void @f1(i8* %dest, i8* %src) {
12entry:
13  ; CHECK-LABEL: f1
14
15  ; CHECK-IOS: bl _memmove
16  ; CHECK-DARWIN: bl _memmove
17  ; CHECK-EABI: bl __aeabi_memmove
18  ; CHECK-GNUEABI: bl memmove
19  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 0, i1 false)
20
21  ; CHECK-IOS: bl _memcpy
22  ; CHECK-DARWIN: bl _memcpy
23  ; CHECK-EABI: bl __aeabi_memcpy
24  ; CHECK-GNUEABI: bl memcpy
25  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 0, i1 false)
26
27  ; EABI memset swaps arguments
28  ; CHECK-IOS: mov r1, #1
29  ; CHECK-IOS: bl _memset
30  ; CHECK-DARWIN: movs r1, #1
31  ; CHECK-DARWIN: bl _memset
32  ; CHECK-EABI: mov r2, #1
33  ; CHECK-EABI: bl __aeabi_memset
34  ; CHECK-GNUEABI: mov r1, #1
35  ; CHECK-GNUEABI: bl memset
36  call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 0, i1 false)
37
38  ; EABI uses memclr if value set to 0
39  ; CHECK-IOS: mov r1, #0
40  ; CHECK-IOS: bl _memset
41  ; CHECK-DARWIN: movs r1, #0
42  ; CHECK-DARWIN: bl _memset
43  ; CHECK-EABI: bl __aeabi_memclr
44  ; CHECK-GNUEABI: bl memset
45  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 0, i1 false)
46
47  ; EABI uses aligned function variants if possible
48
49  ; CHECK-IOS: bl _memmove
50  ; CHECK-DARWIN: bl _memmove
51  ; CHECK-EABI: bl __aeabi_memmove4
52  ; CHECK-GNUEABI: bl memmove
53  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 4, i1 false)
54
55  ; CHECK-IOS: bl _memcpy
56  ; CHECK-DARWIN: bl _memcpy
57  ; CHECK-EABI: bl __aeabi_memcpy4
58  ; CHECK-GNUEABI: bl memcpy
59  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 4, i1 false)
60
61  ; CHECK-IOS: bl _memset
62  ; CHECK-DARWIN: bl _memset
63  ; CHECK-EABI: bl __aeabi_memset4
64  ; CHECK-GNUEABI: bl memset
65  call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 4, i1 false)
66
67  ; CHECK-IOS: bl _memset
68  ; CHECK-DARWIN: bl _memset
69  ; CHECK-EABI: bl __aeabi_memclr4
70  ; CHECK-GNUEABI: bl memset
71  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 4, i1 false)
72
73  ; CHECK-IOS: bl _memmove
74  ; CHECK-DARWIN: bl _memmove
75  ; CHECK-EABI: bl __aeabi_memmove8
76  ; CHECK-GNUEABI: bl memmove
77  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 8, i1 false)
78
79  ; CHECK-IOS: bl _memcpy
80  ; CHECK-DARWIN: bl _memcpy
81  ; CHECK-EABI: bl __aeabi_memcpy8
82  ; CHECK-GNUEABI: bl memcpy
83  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 500, i32 8, i1 false)
84
85  ; CHECK-IOS: bl _memset
86  ; CHECK-DARWIN: bl _memset
87  ; CHECK-EABI: bl __aeabi_memset8
88  ; CHECK-GNUEABI: bl memset
89  call void @llvm.memset.p0i8.i32(i8* %dest, i8 1, i32 500, i32 8, i1 false)
90
91  ; CHECK-IOS: bl _memset
92  ; CHECK-DARWIN: bl _memset
93  ; CHECK-EABI: bl __aeabi_memclr8
94  ; CHECK-GNUEABI: bl memset
95  call void @llvm.memset.p0i8.i32(i8* %dest, i8 0, i32 500, i32 8, i1 false)
96
97  unreachable
98}
99
100; Check that alloca arguments to memory intrinsics are automatically aligned if at least 8 bytes in size
101define void @f2(i8* %dest, i32 %n) {
102entry:
103  ; CHECK-LABEL: f2
104
105  ; IOS (ARMv7) should 8-byte align, others should 4-byte align
106  ; CHECK-IOS: add r1, sp, #32
107  ; CHECK-IOS: bl _memmove
108  ; CHECK-DARWIN: add r1, sp, #28
109  ; CHECK-DARWIN: bl _memmove
110  ; CHECK-EABI: add r1, sp, #28
111  ; CHECK-EABI: bl __aeabi_memmove
112  ; CHECK-GNUEABI: add r1, sp, #28
113  ; CHECK-GNUEABI: bl memmove
114  %arr0 = alloca [9 x i8], align 1
115  %0 = bitcast [9 x i8]* %arr0 to i8*
116  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
117
118  ; CHECK: add r1, sp, #16
119  ; CHECK-IOS: bl _memcpy
120  ; CHECK-DARWIN: bl _memcpy
121  ; CHECK-EABI: bl __aeabi_memcpy
122  ; CHECK-GNUEABI: bl memcpy
123  %arr1 = alloca [9 x i8], align 1
124  %1 = bitcast [9 x i8]* %arr1 to i8*
125  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
126
127  ; CHECK-IOS: mov r0, sp
128  ; CHECK-IOS: mov r1, #1
129  ; CHECK-IOS: bl _memset
130  ; CHECK-DARWIN: add r0, sp, #4
131  ; CHECK-DARWIN: movs r1, #1
132  ; CHECK-DARWIN: bl _memset
133  ; CHECK-EABI: add r0, sp, #4
134  ; CHECK-EABI: mov r2, #1
135  ; CHECK-EABI: bl __aeabi_memset
136  ; CHECK-GNUEABI: add r0, sp, #4
137  ; CHECK-GNUEABI: mov r1, #1
138  ; CHECK-GNUEABI: bl memset
139  %arr2 = alloca [9 x i8], align 1
140  %2 = bitcast [9 x i8]* %arr2 to i8*
141  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
142
143  unreachable
144}
145
146; Check that alloca arguments are not aligned if less than 8 bytes in size
147define void @f3(i8* %dest, i32 %n) {
148entry:
149  ; CHECK-LABEL: f3
150
151  ; CHECK: {{add(.w)? r1, sp, #17|sub(.w)? r1, r7, #15}}
152  ; CHECK-IOS: bl _memmove
153  ; CHECK-DARWIN: bl _memmove
154  ; CHECK-EABI: bl __aeabi_memmove
155  ; CHECK-GNUEABI: bl memmove
156  %arr0 = alloca [7 x i8], align 1
157  %0 = bitcast [7 x i8]* %arr0 to i8*
158  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
159
160  ; CHECK: {{add(.w)? r1, sp, #10}}
161  ; CHECK-IOS: bl _memcpy
162  ; CHECK-DARWIN: bl _memcpy
163  ; CHECK-EABI: bl __aeabi_memcpy
164  ; CHECK-GNUEABI: bl memcpy
165  %arr1 = alloca [7 x i8], align 1
166  %1 = bitcast [7 x i8]* %arr1 to i8*
167  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
168
169  ; CHECK: {{add(.w)? r0, sp, #3}}
170  ; CHECK-IOS: mov r1, #1
171  ; CHECK-IOS: bl _memset
172  ; CHECK-DARWIN: movs r1, #1
173  ; CHECK-DARWIN: bl _memset
174  ; CHECK-EABI: mov r2, #1
175  ; CHECK-EABI: bl __aeabi_memset
176  ; CHECK-GNUEABI: mov r1, #1
177  ; CHECK-GNUEABI: bl memset
178  %arr2 = alloca [7 x i8], align 1
179  %2 = bitcast [7 x i8]* %arr2 to i8*
180  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
181
182  unreachable
183}
184
185; Check that alloca arguments are not aligned if size+offset is less than 8 bytes
186define void @f4(i8* %dest, i32 %n) {
187entry:
188  ; CHECK-LABEL: f4
189
190  ; CHECK: {{add(.w)? r., sp, #23|sub(.w)? r., r7, #17}}
191  ; CHECK-IOS: bl _memmove
192  ; CHECK-DARWIN: bl _memmove
193  ; CHECK-EABI: bl __aeabi_memmove
194  ; CHECK-GNUEABI: bl memmove
195  %arr0 = alloca [9 x i8], align 1
196  %0 = getelementptr inbounds [9 x i8], [9 x i8]* %arr0, i32 0, i32 4
197  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
198
199  ; CHECK: {{add(.w)? r., sp, #(10|14)}}
200  ; CHECK-IOS: bl _memcpy
201  ; CHECK-DARWIN: bl _memcpy
202  ; CHECK-EABI: bl __aeabi_memcpy
203  ; CHECK-GNUEABI: bl memcpy
204  %arr1 = alloca [9 x i8], align 1
205  %1 = getelementptr inbounds [9 x i8], [9 x i8]* %arr1, i32 0, i32 4
206  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
207
208  ; CHECK: {{add(.w)? r., sp, #(1|5)}}
209  ; CHECK-IOS: mov r1, #1
210  ; CHECK-IOS: bl _memset
211  ; CHECK-DARWIN: movs r1, #1
212  ; CHECK-DARWIN: bl _memset
213  ; CHECK-EABI: mov r2, #1
214  ; CHECK-EABI: bl __aeabi_memset
215  ; CHECK-GNUEABI: mov r1, #1
216  ; CHECK-GNUEABI: bl memset
217  %arr2 = alloca [9 x i8], align 1
218  %2 = getelementptr inbounds [9 x i8], [9 x i8]* %arr2, i32 0, i32 4
219  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
220
221  unreachable
222}
223
224; Check that alloca arguments are not aligned if the offset is not a multiple of 4
225define void @f5(i8* %dest, i32 %n) {
226entry:
227  ; CHECK-LABEL: f5
228
229  ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r7, #21}}
230  ; CHECK-IOS: bl _memmove
231  ; CHECK-DARWIN: bl _memmove
232  ; CHECK-EABI: bl __aeabi_memmove
233  ; CHECK-GNUEABI: bl memmove
234  %arr0 = alloca [13 x i8], align 1
235  %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 1
236  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
237
238  ; CHECK: {{add(.w)? r., sp, #(10|14)}}
239  ; CHECK-IOS: bl _memcpy
240  ; CHECK-DARWIN: bl _memcpy
241  ; CHECK-EABI: bl __aeabi_memcpy
242  ; CHECK-GNUEABI: bl memcpy
243  %arr1 = alloca [13 x i8], align 1
244  %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 1
245  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
246
247  ; CHECK: {{add(.w)? r., sp, #(1|5)}}
248  ; CHECK-IOS: mov r1, #1
249  ; CHECK-IOS: bl _memset
250  ; CHECK-DARWIN: movs r1, #1
251  ; CHECK-DARWIN: bl _memset
252  ; CHECK-EABI: mov r2, #1
253  ; CHECK-EABI: bl __aeabi_memset
254  ; CHECK-GNUEABI: mov r1, #1
255  ; CHECK-GNUEABI: bl memset
256  %arr2 = alloca [13 x i8], align 1
257  %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 1
258  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
259
260  unreachable
261}
262
263; Check that alloca arguments are not aligned if the offset is unknown
264define void @f6(i8* %dest, i32 %n, i32 %i) {
265entry:
266  ; CHECK-LABEL: f6
267
268  ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r7, #25}}
269  ; CHECK-IOS: bl _memmove
270  ; CHECK-DARWIN: bl _memmove
271  ; CHECK-EABI: bl __aeabi_memmove
272  ; CHECK-GNUEABI: bl memmove
273  %arr0 = alloca [13 x i8], align 1
274  %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 %i
275  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
276
277  ; CHECK: {{add(.w)? r., sp, #(10|14)}}
278  ; CHECK-IOS: bl _memcpy
279  ; CHECK-DARWIN: bl _memcpy
280  ; CHECK-EABI: bl __aeabi_memcpy
281  ; CHECK-GNUEABI: bl memcpy
282  %arr1 = alloca [13 x i8], align 1
283  %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 %i
284  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
285
286  ; CHECK: {{add(.w)? r., sp, #(1|5)}}
287  ; CHECK-IOS: mov r1, #1
288  ; CHECK-IOS: bl _memset
289  ; CHECK-DARWIN: movs r1, #1
290  ; CHECK-DARWIN: bl _memset
291  ; CHECK-EABI: mov r2, #1
292  ; CHECK-EABI: bl __aeabi_memset
293  ; CHECK-GNUEABI: mov r1, #1
294  ; CHECK-GNUEABI: bl memset
295  %arr2 = alloca [13 x i8], align 1
296  %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 %i
297  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
298
299  unreachable
300}
301
302; Check that alloca arguments are not aligned if the GEP is not inbounds
303define void @f7(i8* %dest, i32 %n) {
304entry:
305  ; CHECK-LABEL: f7
306
307  ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r7, #21}}
308  ; CHECK-IOS: bl _memmove
309  ; CHECK-DARWIN: bl _memmove
310  ; CHECK-EABI: bl __aeabi_memmove
311  ; CHECK-GNUEABI: bl memmove
312  %arr0 = alloca [13 x i8], align 1
313  %0 = getelementptr [13 x i8], [13 x i8]* %arr0, i32 0, i32 4
314  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
315
316  ; CHECK: {{add(.w)? r., sp, #(10|14)}}
317  ; CHECK-IOS: bl _memcpy
318  ; CHECK-DARWIN: bl _memcpy
319  ; CHECK-EABI: bl __aeabi_memcpy
320  ; CHECK-GNUEABI: bl memcpy
321  %arr1 = alloca [13 x i8], align 1
322  %1 = getelementptr [13 x i8], [13 x i8]* %arr1, i32 0, i32 4
323  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
324
325  ; CHECK: {{add(.w)? r., sp, #(1|5)}}
326  ; CHECK-IOS: mov r1, #1
327  ; CHECK-IOS: bl _memset
328  ; CHECK-DARWIN: movs r1, #1
329  ; CHECK-DARWIN: bl _memset
330  ; CHECK-EABI: mov r2, #1
331  ; CHECK-EABI: bl __aeabi_memset
332  ; CHECK-GNUEABI: mov r1, #1
333  ; CHECK-GNUEABI: bl memset
334  %arr2 = alloca [13 x i8], align 1
335  %2 = getelementptr [13 x i8], [13 x i8]* %arr2, i32 0, i32 4
336  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
337
338  unreachable
339}
340
341; Check that alloca arguments are not aligned when the offset is past the end of the allocation
342define void @f8(i8* %dest, i32 %n) {
343entry:
344  ; CHECK-LABEL: f8
345
346  ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r7, #21}}
347  ; CHECK-IOS: bl _memmove
348  ; CHECK-DARWIN: bl _memmove
349  ; CHECK-EABI: bl __aeabi_memmove
350  ; CHECK-GNUEABI: bl memmove
351  %arr0 = alloca [13 x i8], align 1
352  %0 = getelementptr inbounds [13 x i8], [13 x i8]* %arr0, i32 0, i32 16
353  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i32 0, i1 false)
354
355  ; CHECK: {{add(.w)? r., sp, #(10|14)}}
356  ; CHECK-IOS: bl _memcpy
357  ; CHECK-DARWIN: bl _memcpy
358  ; CHECK-EABI: bl __aeabi_memcpy
359  ; CHECK-GNUEABI: bl memcpy
360  %arr1 = alloca [13 x i8], align 1
361  %1 = getelementptr inbounds [13 x i8], [13 x i8]* %arr1, i32 0, i32 16
362  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i32 0, i1 false)
363
364  ; CHECK: {{add(.w)? r., sp, #(1|5)}}
365  ; CHECK-IOS: mov r1, #1
366  ; CHECK-IOS: bl _memset
367  ; CHECK-DARWIN: movs r1, #1
368  ; CHECK-DARWIN: bl _memset
369  ; CHECK-EABI: mov r2, #1
370  ; CHECK-EABI: bl __aeabi_memset
371  ; CHECK-GNUEABI: mov r1, #1
372  ; CHECK-GNUEABI: bl memset
373  %arr2 = alloca [13 x i8], align 1
374  %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 16
375  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i32 0, i1 false)
376
377  unreachable
378}
379
380; Check that global variables are aligned if they are large enough, but only if
381; they are defined in this object and don't have an explicit section.
382@arr1 = global [7 x i8] c"\01\02\03\04\05\06\07", align 1
383@arr2 = global [8 x i8] c"\01\02\03\04\05\06\07\08", align 1
384@arr3 = global [7 x i8] c"\01\02\03\04\05\06\07", section "foo,bar", align 1
385@arr4 = global [8 x i8] c"\01\02\03\04\05\06\07\08", section "foo,bar", align 1
386@arr5 = weak global [7 x i8] c"\01\02\03\04\05\06\07", align 1
387@arr6 = weak_odr global [7 x i8] c"\01\02\03\04\05\06\07", align 1
388@arr7 = external global [7 x i8], align 1
389define void @f9(i8* %dest, i32 %n) {
390entry:
391  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr1, i32 0, i32 0), i32 %n, i32 1, i1 false)
392  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @arr2, i32 0, i32 0), i32 %n, i32 1, i1 false)
393  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr3, i32 0, i32 0), i32 %n, i32 1, i1 false)
394  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @arr4, i32 0, i32 0), i32 %n, i32 1, i1 false)
395  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr5, i32 0, i32 0), i32 %n, i32 1, i1 false)
396  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr6, i32 0, i32 0), i32 %n, i32 1, i1 false)
397  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @arr7, i32 0, i32 0), i32 %n, i32 1, i1 false)
398
399  unreachable
400}
401
402; CHECK: {{\.data|\.section.+data}}
403; CHECK-NOT: .p2align
404; CHECK: arr1:
405; CHECK-IOS: .p2align 3
406; CHECK-DARWIN: .p2align 2
407; CHECK-EABI-NOT: .p2align
408; CHECK-GNUEABI-NOT: .p2align
409; CHECK: arr2:
410; CHECK: {{\.section.+foo,bar}}
411; CHECK-NOT: .p2align
412; CHECK: arr3:
413; CHECK-NOT: .p2align
414; CHECK: arr4:
415; CHECK: {{\.data|\.section.+data}}
416; CHECK-NOT: .p2align
417; CHECK: arr5:
418; CHECK-NOT: .p2align
419; CHECK: arr6:
420; CHECK-NOT: arr7:
421
422declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
423declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
424declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
425