test/CodeGen/AArch64/alloca.ll

   1 ; RUN: llc -mtriple=aarch64-none-linux-gnu -verify-machineinstrs < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-AARCH64
   2 ; RUN: llc -mtriple=arm64 -verify-machineinstrs -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ARM64
   3 ; RUN: llc -mtriple=aarch64-none-linux-gnu -mattr=-fp-armv8 -verify-machineinstrs < %s | FileCheck --check-prefix=CHECK-NOFP %s
   4
   5 declare void @use_addr(i8*)
   6
   7 define void @test_simple_alloca(i64 %n) {
   8 ; CHECK-LABEL: test_simple_alloca:
   9
  10   %buf = alloca i8, i64 %n
  11   ; Make sure we align the stack change to 16 bytes:
  12 ; CHECK: {{mov|add}} x29
  13 ; CHECK: mov [[TMP:x[0-9]+]], sp
  14 ; CHECK: add [[SPDELTA_TMP:x[0-9]+]], x0, #15
  15 ; CHECK: and [[SPDELTA:x[0-9]+]], [[SPDELTA_TMP]], #0xfffffffffffffff0
  16
  17   ; Make sure we change SP. It would be surprising if anything but x0 were used
  18   ; for the final sp, but it could be if it was then moved into x0.
  19 ; CHECK: sub [[NEWSP:x[0-9]+]], [[TMP]], [[SPDELTA]]
  20 ; CHECK: mov sp, [[NEWSP]]
  21
  22   call void @use_addr(i8* %buf)
  23 ; CHECK: bl use_addr
  24
  25   ret void
  26   ; Make sure epilogue restores sp from fp
  27 ; CHECK: {{sub|mov}} sp, x29
  28 ; CHECK: ret
  29 }
  30
  31 declare void @use_addr_loc(i8*, i64*)
  32
  33 define i64 @test_alloca_with_local(i64 %n) {
  34 ; CHECK-LABEL: test_alloca_with_local:
  35 ; CHECK-DAG: sub sp, sp, [[LOCAL_STACK:#[0-9]+]]
  36 ; CHECK-DAG: {{mov|add}} x29, sp
  37
  38   %loc = alloca i64
  39   %buf = alloca i8, i64 %n
  40   ; Make sure we align the stack change to 16 bytes:
  41 ; CHECK: mov [[TMP:x[0-9]+]], sp
  42 ; CHECK: add [[SPDELTA_TMP:x[0-9]+]], x0, #15
  43 ; CHECK: and [[SPDELTA:x[0-9]+]], [[SPDELTA_TMP]], #0xfffffffffffffff0
  44
  45   ; Make sure we change SP. It would be surprising if anything but x0 were used
  46   ; for the final sp, but it could be if it was then moved into x0.
  47 ; CHECK: sub [[NEWSP:x[0-9]+]], [[TMP]], [[SPDELTA]]
  48 ; CHECK: mov sp, [[NEWSP]]
  49
  50 ; CHECK: sub {{x[0-9]+}}, x29, #[[LOC_FROM_FP:[0-9]+]]
  51
  52   call void @use_addr_loc(i8* %buf, i64* %loc)
  53 ; CHECK: bl use_addr
  54
  55   %val = load i64* %loc
  56 ; CHECK-AARCH64: sub x[[TMP:[0-9]+]], x29, #[[LOC_FROM_FP]]
  57 ; CHECK-AARCH64: ldr x0, [x[[TMP]]]
  58
  59 ; CHECK-ARM64: ldur x0, [x29, #-[[LOC_FROM_FP]]]
  60
  61   ret i64 %val
  62   ; Make sure epilogue restores sp from fp
  63 ; CHECK: {{sub|mov}} sp, x29
  64 ; CHECK: ret
  65 }
  66
  67 define void @test_variadic_alloca(i64 %n, ...) {
  68 ; CHECK-LABEL: test_variadic_alloca:
  69
  70 ; CHECK-AARCH64: sub     sp, sp, #{{[0-9]+}}
  71 ; CHECK-AARCH64: add     x29, sp, #192
  72 ; CHECK-AARCH64: sub     [[TMP:x[0-9]+]], x29, #192
  73 ; CHECK-AARCH64: add     x8, [[TMP]], #0
  74 ; CHECK-AARCH64-FP: str     q7, [x8, #112]
  75 ; [...]
  76 ; CHECK-AARCH64-FP: str     q1, [x8, #16]
  77
  78
  79 ; CHECK-NOFP: sub     sp, sp, #80
  80 ; CHECK-NOFP: stp     x29, x30, [sp, #64]
  81 ; CHECK-NOFP: add     x29, sp, #64
  82 ; CHECK-NOFP: sub     [[TMP:x[0-9]+]], x29, #64
  83 ; CHECK-NOFP: add     x8, [[TMP]], #0
  84
  85
  86 ; CHECK-ARM64: stp     x29, x30, [sp, #-16]!
  87 ; CHECK-ARM64: mov     x29, sp
  88 ; CHECK-ARM64: sub     sp, sp, #192
  89 ; CHECK-ARM64: stp     q6, q7, [x29, #-96]
  90 ; [...]
  91 ; CHECK-ARM64: stp     q0, q1, [x29, #-192]
  92
  93 ; CHECK-ARM64: stp     x6, x7, [x29, #-16]
  94 ; [...]
  95 ; CHECK-ARM64: stp     x2, x3, [x29, #-48]
  96
  97
  98   %addr = alloca i8, i64 %n
  99
 100   call void @use_addr(i8* %addr)
 101 ; CHECK: bl use_addr
 102
 103   ret void
 104 ; CHECK-AARCH64: sub sp, x29, #192
 105 ; CHECK-AARCH64: ldp x29, x30, [sp, #192]
 106 ; CHECK-AARCH64: add sp, sp, #208
 107
 108 ; CHECK-NOFP: sub sp, x29, #64
 109 ; CHECK-NOFP: ldp x29, x30, [sp, #64]
 110 ; CHECK-NOFP: add sp, sp, #80
 111 }
 112
 113 define void @test_alloca_large_frame(i64 %n) {
 114 ; CHECK-LABEL: test_alloca_large_frame:
 115
 116 ; CHECK-AARCH64: sub sp, sp, #496
 117 ; CHECK-AARCH64: stp x29, x30, [sp, #480]
 118 ; CHECK-AARCH64: add x29, sp, #480
 119 ; CHECK-AARCH64: sub sp, sp, #48
 120 ; CHECK-AARCH64: sub sp, sp, #1953, lsl #12
 121
 122 ; CHECK-ARM64: stp     x20, x19, [sp, #-32]!
 123 ; CHECK-ARM64: stp     x29, x30, [sp, #16]
 124 ; CHECK-ARM64: add     x29, sp, #16
 125 ; CHECK-ARM64: sub     sp, sp, #7999488
 126 ; CHECK-ARM64: sub     sp, sp, #512
 127
 128   %addr1 = alloca i8, i64 %n
 129   %addr2 = alloca i64, i64 1000000
 130
 131   call void @use_addr_loc(i8* %addr1, i64* %addr2)
 132
 133   ret void
 134 ; CHECK-AARCH64: sub sp, x29, #480
 135 ; CHECK-AARCH64: ldp x29, x30, [sp, #480]
 136 ; CHECK-AARCH64: add sp, sp, #496
 137
 138 ; CHECK-ARM64: sub     sp, x29, #16
 139 ; CHECK-ARM64: ldp     x29, x30, [sp, #16]
 140 ; CHECK-ARM64: ldp     x20, x19, [sp], #32
 141 }
 142
 143 declare i8* @llvm.stacksave()
 144 declare void @llvm.stackrestore(i8*)
 145
 146 define void @test_scoped_alloca(i64 %n) {
 147 ; CHECK-LABEL: test_scoped_alloca:
 148
 149   %sp = call i8* @llvm.stacksave()
 150 ; CHECK: mov [[SAVED_SP:x[0-9]+]], sp
 151 ; CHECK: mov [[OLDSP:x[0-9]+]], sp
 152
 153   %addr = alloca i8, i64 %n
 154 ; CHECK: and [[SPDELTA:x[0-9]+]], {{x[0-9]+}}, #0xfffffffffffffff0
 155 ; CHECK-DAG: sub [[NEWSP:x[0-9]+]], [[OLDSP]], [[SPDELTA]]
 156 ; CHECK: mov sp, [[NEWSP]]
 157
 158   call void @use_addr(i8* %addr)
 159 ; CHECK: bl use_addr
 160
 161   call void @llvm.stackrestore(i8* %sp)
 162 ; CHECK: mov sp, [[SAVED_SP]]
 163
 164   ret void
 165 }