1; RUN: opt -safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s 2; RUN: opt -safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s 3; RUN: opt -passes=safe-stack -S -mtriple=i386-pc-linux-gnu < %s -o - | FileCheck %s 4; RUN: opt -passes=safe-stack -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s 5 6target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 7target triple = "x86_64-unknown-linux-gnu" 8 9@.str = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 10 11; no arrays / no nested arrays 12; Requires no protector. 13 14define void @foo(ptr %a) nounwind uwtable safestack { 15entry: 16 ; CHECK-LABEL: define void @foo( 17 ; CHECK-NOT: __safestack_unsafe_stack_ptr 18 ; CHECK: ret void 19 %a.addr = alloca ptr, align 8 20 store ptr %a, ptr %a.addr, align 8 21 %0 = load ptr, ptr %a.addr, align 8 22 %call = call i32 (ptr, ...) @printf(ptr @.str, ptr %0) 23 ret void 24} 25 26declare i32 @printf(ptr, ...) 27 28define void @call_memset(i64 %len) safestack { 29entry: 30 ; CHECK-LABEL: define void @call_memset 31 ; CHECK: @__safestack_unsafe_stack_ptr 32 ; CHECK: ret void 33 %q = alloca [10 x i8], align 1 34 call void @llvm.memset.p0.i64(ptr %q, i8 1, i64 %len, i1 false) 35 ret void 36} 37 38define void @call_constant_memset() safestack { 39entry: 40 ; CHECK-LABEL: define void @call_constant_memset 41 ; CHECK-NOT: @__safestack_unsafe_stack_ptr 42 ; CHECK: ret void 43 %q = alloca [10 x i8], align 1 44 %arraydecay = getelementptr inbounds [10 x i8], ptr %q, i32 0, i32 2 45 call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 7, i1 false) 46 ret void 47} 48 49define void @call_constant_overflow_memset() safestack { 50entry: 51 ; CHECK-LABEL: define void @call_constant_overflow_memset 52 ; CHECK: @__safestack_unsafe_stack_ptr 53 ; CHECK: ret void 54 %q = alloca [10 x i8], align 1 55 %arraydecay = getelementptr inbounds [10 x i8], ptr %q, i32 0, i32 7 56 call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 5, i1 false) 57 ret void 58} 59 60define void @call_constant_underflow_memset() safestack { 61entry: 62 ; CHECK-LABEL: define void @call_constant_underflow_memset 63 ; CHECK: @__safestack_unsafe_stack_ptr 64 ; CHECK: ret void 65 %q = alloca [10 x i8], align 1 66 %arraydecay = getelementptr [10 x i8], ptr %q, i32 0, i32 -1 67 call void @llvm.memset.p0.i64(ptr %arraydecay, i8 1, i64 3, i1 false) 68 ret void 69} 70 71; Readnone nocapture -> safe 72define void @call_readnone(i64 %len) safestack { 73entry: 74 ; CHECK-LABEL: define void @call_readnone 75 ; CHECK-NOT: @__safestack_unsafe_stack_ptr 76 ; CHECK: ret void 77 %q = alloca [10 x i8], align 1 78 call void @readnone(ptr %q) 79 ret void 80} 81 82; Arg0 is readnone, arg1 is not. Pass alloca ptr as arg0 -> safe 83define void @call_readnone0_0(i64 %len) safestack { 84entry: 85 ; CHECK-LABEL: define void @call_readnone0_0 86 ; CHECK-NOT: @__safestack_unsafe_stack_ptr 87 ; CHECK: ret void 88 %q = alloca [10 x i8], align 1 89 call void @readnone0(ptr %q, ptr zeroinitializer) 90 ret void 91} 92 93; Arg0 is readnone, arg1 is not. Pass alloca ptr as arg1 -> unsafe 94define void @call_readnone0_1(i64 %len) safestack { 95entry: 96 ; CHECK-LABEL: define void @call_readnone0_1 97 ; CHECK: @__safestack_unsafe_stack_ptr 98 ; CHECK: ret void 99 %q = alloca [10 x i8], align 1 100 call void @readnone0(ptr zeroinitializer, ptr %q) 101 ret void 102} 103 104; Readonly nocapture -> unsafe 105define void @call_readonly(i64 %len) safestack { 106entry: 107 ; CHECK-LABEL: define void @call_readonly 108 ; CHECK: @__safestack_unsafe_stack_ptr 109 ; CHECK: ret void 110 %q = alloca [10 x i8], align 1 111 call void @readonly(ptr %q) 112 ret void 113} 114 115; Readonly nocapture -> unsafe 116define void @call_arg_readonly(i64 %len) safestack { 117entry: 118 ; CHECK-LABEL: define void @call_arg_readonly 119 ; CHECK: @__safestack_unsafe_stack_ptr 120 ; CHECK: ret void 121 %q = alloca [10 x i8], align 1 122 call void @arg_readonly(ptr %q) 123 ret void 124} 125 126; Readwrite nocapture -> unsafe 127define void @call_readwrite(i64 %len) safestack { 128entry: 129 ; CHECK-LABEL: define void @call_readwrite 130 ; CHECK: @__safestack_unsafe_stack_ptr 131 ; CHECK: ret void 132 %q = alloca [10 x i8], align 1 133 call void @readwrite(ptr %q) 134 ret void 135} 136 137; Captures the argument -> unsafe 138define void @call_capture(i64 %len) safestack { 139entry: 140 ; CHECK-LABEL: define void @call_capture 141 ; CHECK: @__safestack_unsafe_stack_ptr 142 ; CHECK: ret void 143 %q = alloca [10 x i8], align 1 144 call void @capture(ptr %q) 145 ret void 146} 147 148; Lifetime intrinsics are always safe. 149define void @call_lifetime(ptr %p) { 150 ; CHECK-LABEL: define void @call_lifetime 151 ; CHECK-NOT: @__safestack_unsafe_stack_ptr 152 ; CHECK: ret void 153entry: 154 %q = alloca [100 x i8], align 16 155 call void @llvm.lifetime.start.p0(i64 100, ptr %q) 156 call void @llvm.lifetime.end.p0(i64 100, ptr %q) 157 ret void 158} 159 160declare void @readonly(ptr nocapture) readonly 161declare void @arg_readonly(ptr readonly nocapture) 162declare void @readwrite(ptr nocapture) 163declare void @capture(ptr readnone) readnone 164 165declare void @readnone(ptr nocapture) readnone 166declare void @readnone0(ptr nocapture readnone, ptr nocapture) 167 168declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) nounwind argmemonly 169 170declare void @llvm.lifetime.start.p0(i64, ptr nocapture) nounwind argmemonly 171declare void @llvm.lifetime.end.p0(i64, ptr nocapture) nounwind argmemonly 172