llvm/test/Transforms/SafeStack/X86/call.ll

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