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