test/CodeGen/AArch64/alloca.ll

   1 ; RUN: llc -mtriple=aarch64-linux-gnu -disable-post-ra -verify-machineinstrs -o - %s | FileCheck %s
   2 ; RUN: llc -mtriple=arm64-apple-ios -disable-post-ra -verify-machineinstrs -o - %s | FileCheck %s --check-prefix=CHECK-MACHO
   3 ; RUN: llc -mtriple=aarch64-none-linux-gnu -disable-post-ra -mattr=-fp-armv8 -verify-machineinstrs < %s | FileCheck --check-prefix=CHECK-NOFP-ARM64 %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, i64* %loc
  56
  57 ; CHECK: ldur x0, [x29, #-[[LOC_FROM_FP]]]
  58
  59   ret i64 %val
  60   ; Make sure epilogue restores sp from fp
  61 ; CHECK: {{sub|mov}} sp, x29
  62 ; CHECK: ret
  63 }
  64
  65 define void @test_variadic_alloca(i64 %n, ...) {
  66 ; CHECK-LABEL: test_variadic_alloca:
  67
  68 ; [...]
  69
  70
  71 ; CHECK-NOFP-AARCH64: sub     sp, sp, #80
  72 ; CHECK-NOFP-AARCH64: stp     x29, x30, [sp, #64]
  73 ; CHECK-NOFP-AARCH64: add     x29, sp, #64
  74 ; CHECK-NOFP-AARCH64: sub     [[TMP:x[0-9]+]], x29, #64
  75 ; CHECK-NOFP-AARCH64: add     x8, [[TMP]], #0
  76
  77
  78 ; CHECK: stp     x29, x30, [sp, #-16]!
  79 ; CHECK: mov     x29, sp
  80 ; CHECK: sub     sp, sp, #192
  81 ; CHECK-DAG: stp     q6, q7, [x29, #-96]
  82 ; [...]
  83 ; CHECK-DAG: stp     q0, q1, [x29, #-192]
  84
  85 ; CHECK-DAG: stp     x5, x6, [x29, #-24]
  86 ; [...]
  87 ; CHECK-DAG: stp     x1, x2, [x29, #-56]
  88
  89 ; CHECK-NOFP-ARM64: stp     x29, x30, [sp, #-16]!
  90 ; CHECK-NOFP-ARM64: mov     x29, sp
  91 ; CHECK-NOFP-ARM64: sub     sp, sp, #64
  92 ; CHECK-NOFP-ARM64-DAG: stp     x5, x6, [x29, #-24]
  93 ; [...]
  94 ; CHECK-NOFP-ARM64-DAG: stp     x3, x4, [x29, #-40]
  95 ; [...]
  96 ; CHECK-NOFP-ARM64-DAG: stp     x1, x2, [x29, #-56]
  97 ; [...]
  98 ; CHECK-NOFP-ARM64: mov     x8, sp
  99
 100   %addr = alloca i8, i64 %n
 101
 102   call void @use_addr(i8* %addr)
 103 ; CHECK: bl use_addr
 104
 105   ret void
 106
 107 ; CHECK-NOFP-AARCH64: sub sp, x29, #64
 108 ; CHECK-NOFP-AARCH64: ldp x29, x30, [sp, #64]
 109 ; CHECK-NOFP-AARCH64: add sp, sp, #80
 110
 111 ; CHECK-NOFP-ARM64: mov sp, x29
 112 ; CHECK-NOFP-ARM64: ldp x29, x30, [sp], #16
 113 }
 114
 115 define void @test_alloca_large_frame(i64 %n) {
 116 ; CHECK-LABEL: test_alloca_large_frame:
 117 ; CHECK-MACHO-LABEL: test_alloca_large_frame:
 118
 119
 120 ; CHECK: stp     x29, x30, [sp, #-32]!
 121 ; CHECK: stp     x28, x19, [sp, #16]
 122 ; CHECK: mov     x29, sp
 123 ; CHECK: sub     sp, sp, #1953, lsl #12
 124 ; CHECK: sub     sp, sp, #512
 125
 126 ; CHECK-MACHO: stp     x20, x19, [sp, #-32]!
 127 ; CHECK-MACHO: stp     x29, x30, [sp, #16]
 128 ; CHECK-MACHO: add     x29, sp, #16
 129 ; CHECK-MACHO: sub     sp, sp, #1953, lsl #12
 130 ; CHECK-MACHO: sub     sp, sp, #512
 131
 132   %addr1 = alloca i8, i64 %n
 133   %addr2 = alloca i64, i64 1000000
 134
 135   call void @use_addr_loc(i8* %addr1, i64* %addr2)
 136
 137   ret void
 138
 139 ; CHECK: mov     sp, x29
 140 ; CHECK: ldp     x28, x19, [sp, #16]
 141 ; CHECK: ldp     x29, x30, [sp], #32
 142
 143 ; CHECK-MACHO: sub     sp, x29, #16
 144 ; CHECK-MACHO: ldp     x29, x30, [sp, #16]
 145 ; CHECK-MACHO: ldp     x20, x19, [sp], #32
 146 }
 147
 148 declare i8* @llvm.stacksave()
 149 declare void @llvm.stackrestore(i8*)
 150
 151 define void @test_scoped_alloca(i64 %n) {
 152 ; CHECK-LABEL: test_scoped_alloca:
 153
 154   %sp = call i8* @llvm.stacksave()
 155 ; CHECK: mov x29, sp
 156 ; CHECK: mov [[SAVED_SP:x[0-9]+]], sp
 157 ; CHECK: mov [[OLDSP:x[0-9]+]], sp
 158
 159   %addr = alloca i8, i64 %n
 160 ; CHECK: and [[SPDELTA:x[0-9]+]], {{x[0-9]+}}, #0xfffffffffffffff0
 161 ; CHECK-DAG: sub [[NEWSP:x[0-9]+]], [[OLDSP]], [[SPDELTA]]
 162 ; CHECK: mov sp, [[NEWSP]]
 163
 164   call void @use_addr(i8* %addr)
 165 ; CHECK: bl use_addr
 166
 167   call void @llvm.stackrestore(i8* %sp)
 168 ; CHECK: mov sp, [[SAVED_SP]]
 169
 170   ret void
 171 }