test/CodeGen/ARM/memfunc.ll

   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) "no-frame-pointer-elim"="true" {
  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, 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, 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, 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, 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* align 4 %dest, i8* align 4 %src, i32 500, 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* align 4 %dest, i8* align 4 %src, i32 500, 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* align 4 %dest, i8 1, i32 500, 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* align 4 %dest, i8 0, i32 500, 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* align 8 %dest, i8* align 8 %src, i32 500, 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* align 8 %dest, i8* align 8 %src, i32 500, 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* align 8 %dest, i8 1, i32 500, 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* align 8 %dest, i8 0, i32 500, 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) "no-frame-pointer-elim"="true" {
 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|sub r1, r(7|11), #20}}
 111   ; CHECK-EABI: bl __aeabi_memmove
 112   ; CHECK-GNUEABI: {{add r1, sp, #28|sub r1, r(7|11), #20}}
 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, 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, 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, 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) "no-frame-pointer-elim"="true" {
 148 entry:
 149   ; CHECK-LABEL: f3
 150
 151   ; CHECK: {{add(.w)? r1, sp, #17|sub(.w)? r1, r(7|11), #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, i1 false)
 159
 160   ; CHECK: {{add(.w)? r1, sp, #10|sub(.w)? r1, r(7|11), #22}}
 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, i1 false)
 168
 169   ; CHECK: {{add(.w)? r0, sp, #3|sub(.w)? r0, r(7|11), #29}}
 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, 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) "no-frame-pointer-elim"="true" {
 187 entry:
 188   ; CHECK-LABEL: f4
 189
 190   ; CHECK: {{add(.w)? r., sp, #23|sub(.w)? r., r(7|11), #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, i1 false)
 198
 199   ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w) r., r(7|11), #26}}
 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, i1 false)
 207
 208   ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w) r., r(7|11), #35}}
 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, 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) "no-frame-pointer-elim"="true" {
 226 entry:
 227   ; CHECK-LABEL: f5
 228
 229   ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #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, i1 false)
 237
 238   ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
 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, i1 false)
 246
 247   ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
 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, 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) "no-frame-pointer-elim"="true" {
 265 entry:
 266   ; CHECK-LABEL: f6
 267
 268   ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #(25|29)}}
 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, i1 false)
 276
 277   ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #42}}
 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, i1 false)
 285
 286   ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #55}}
 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, 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) "no-frame-pointer-elim"="true" {
 304 entry:
 305   ; CHECK-LABEL: f7
 306
 307   ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #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, i1 false)
 315
 316   ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
 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, i1 false)
 324
 325   ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
 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, 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) "no-frame-pointer-elim"="true" {
 343 entry:
 344   ; CHECK-LABEL: f8
 345
 346   ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #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, i1 false)
 354
 355   ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #34}}
 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, i1 false)
 363
 364   ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #47}}
 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, 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 @arr8 = internal global [128 x i8] undef
 390 @arr9 = weak_odr global [128 x i8] undef
 391 @arr10 = dso_local global [8 x i8] c"\01\02\03\04\05\06\07\08", align 1
 392 define void @f9(i8* %dest, i32 %n) "no-frame-pointer-elim"="true" {
 393 entry:
 394   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, i1 false)
 395   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, i1 false)
 396   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, i1 false)
 397   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, i1 false)
 398   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, i1 false)
 399   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, i1 false)
 400   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, i1 false)
 401   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([128 x i8], [128 x i8]* @arr8, i32 0, i32 0), i32 %n, i1 false)
 402   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([128 x i8], [128 x i8]* @arr9, i32 0, i32 0), i32 %n, i1 false)
 403   call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @arr10, i32 0, i32 0), i32 %n, i1 false)
 404   unreachable
 405 }
 406
 407 ; CHECK: {{\.data|\.section.+data}}
 408 ; CHECK-NOT: .p2align
 409 ; CHECK: arr1:
 410 ; CHECK-IOS: .p2align 3
 411 ; CHECK-DARWIN: .p2align 2
 412 ; CHECK-EABI-NOT: .p2align
 413 ; CHECK-GNUEABI-NOT: .p2align
 414 ; CHECK: arr2:
 415 ; CHECK: {{\.section.+foo,bar}}
 416 ; CHECK-NOT: .p2align
 417 ; CHECK: arr3:
 418 ; CHECK-NOT: .p2align
 419 ; CHECK: arr4:
 420 ; CHECK: {{\.data|\.section.+data}}
 421 ; CHECK-NOT: .p2align
 422 ; CHECK: arr5:
 423 ; CHECK-NOT: .p2align
 424 ; CHECK: arr6:
 425 ; CHECK-IOS: arr8,128,4
 426 ; CHECK-DARWIN: arr8,128,4
 427 ; CHECK-EABI: arr8,128,16
 428 ; CHECK-GNUEABI: arr8,128,16
 429 ; CHECK: .p2align 4
 430 ; CHECK: arr9:
 431 ; CHECK-IOS: .p2align 3
 432 ; CHECK-DARWIN: .p2align 2
 433 ; CHECK-EABI: .p2align 2
 434 ; CHECK-GNUEABI: .p2align 2
 435 ; CHECK: arr10:
 436
 437 ; CHECK-NOT: arr7:
 438
 439 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
 440 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
 441 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind