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