test/CodeGen/AArch64/alloca.ll

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