Home | History | Annotate | Download | only in ARM 
      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 
     11 define void @f1(i8* %dest, i8* %src) {
     12 entry:
     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
    101 define void @f2(i8* %dest, i32 %n) {
    102 entry:
    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
    147 define void @f3(i8* %dest, i32 %n) {
    148 entry:
    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
    186 define void @f4(i8* %dest, i32 %n) {
    187 entry:
    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
    225 define void @f5(i8* %dest, i32 %n) {
    226 entry:
    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
    264 define void @f6(i8* %dest, i32 %n, i32 %i) {
    265 entry:
    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
    303 define void @f7(i8* %dest, i32 %n) {
    304 entry:
    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
    342 define void @f8(i8* %dest, i32 %n) {
    343 entry:
    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
    389 define void @f9(i8* %dest, i32 %n) {
    390 entry:
    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 
    422 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
    423 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
    424 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
    425