test/Transforms/Inline/byval.ll

   1 ; RUN: opt < %s -inline -S | FileCheck %s
   2 ; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
   3
   4 ; The verifier does catch problems with inlining of byval arguments that has a
   5 ; different address space compared to the alloca. But running instcombine
   6 ; after inline used to trigger asserts unless we disallow such inlining.
   7 ; RUN: opt < %s -inline -instcombine -disable-output 2>/dev/null
   8
   9 target datalayout = "p:32:32-p1:64:64-p2:16:16-n16:32:64"
  10
  11 ; Inlining a byval struct should cause an explicit copy into an alloca.
  12
  13         %struct.ss = type { i32, i64 }
  14 @.str = internal constant [10 x i8] c"%d, %lld\0A\00"           ; <[10 x i8]*> [#uses=1]
  15
  16 define internal void @f(%struct.ss* byval  %b) nounwind  {
  17 entry:
  18         %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0           ; <i32*> [#uses=2]
  19         %tmp1 = load i32, i32* %tmp, align 4            ; <i32> [#uses=1]
  20         %tmp2 = add i32 %tmp1, 1                ; <i32> [#uses=1]
  21         store i32 %tmp2, i32* %tmp, align 4
  22         ret void
  23 }
  24
  25 declare i32 @printf(i8*, ...) nounwind
  26
  27 define i32 @test1() nounwind  {
  28 entry:
  29         %S = alloca %struct.ss          ; <%struct.ss*> [#uses=4]
  30         %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0          ; <i32*> [#uses=1]
  31         store i32 1, i32* %tmp1, align 8
  32         %tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1          ; <i64*> [#uses=1]
  33         store i64 2, i64* %tmp4, align 4
  34         call void @f( %struct.ss* byval  %S ) nounwind
  35         ret i32 0
  36 ; CHECK: @test1()
  37 ; CHECK: %S1 = alloca %struct.ss
  38 ; CHECK: %S = alloca %struct.ss
  39 ; CHECK: call void @llvm.memcpy
  40 ; CHECK: ret i32 0
  41 }
  42
  43 ; Inlining a byval struct should NOT cause an explicit copy
  44 ; into an alloca if the function is readonly
  45
  46 define internal i32 @f2(%struct.ss* byval  %b) nounwind readonly {
  47 entry:
  48         %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0           ; <i32*> [#uses=2]
  49         %tmp1 = load i32, i32* %tmp, align 4            ; <i32> [#uses=1]
  50         %tmp2 = add i32 %tmp1, 1                ; <i32> [#uses=1]
  51         ret i32 %tmp2
  52 }
  53
  54 define i32 @test2() nounwind  {
  55 entry:
  56         %S = alloca %struct.ss          ; <%struct.ss*> [#uses=4]
  57         %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0          ; <i32*> [#uses=1]
  58         store i32 1, i32* %tmp1, align 8
  59         %tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1          ; <i64*> [#uses=1]
  60         store i64 2, i64* %tmp4, align 4
  61         %X = call i32 @f2( %struct.ss* byval  %S ) nounwind
  62         ret i32 %X
  63 ; CHECK: @test2()
  64 ; CHECK: %S = alloca %struct.ss
  65 ; CHECK-NOT: call void @llvm.memcpy
  66 ; CHECK: ret i32
  67 }
  68
  69
  70 ; Inlining a byval with an explicit alignment needs to use *at least* that
  71 ; alignment on the generated alloca.
  72 ; PR8769
  73 declare void @g3(%struct.ss* %p)
  74
  75 define internal void @f3(%struct.ss* byval align 64 %b) nounwind {
  76    call void @g3(%struct.ss* %b)  ;; Could make alignment assumptions!
  77    ret void
  78 }
  79
  80 define void @test3() nounwind  {
  81 entry:
  82         %S = alloca %struct.ss, align 1  ;; May not be aligned.
  83         call void @f3( %struct.ss* byval align 64 %S) nounwind
  84         ret void
  85 ; CHECK: @test3()
  86 ; CHECK: %S1 = alloca %struct.ss, align 64
  87 ; CHECK: %S = alloca %struct.ss
  88 ; CHECK: call void @llvm.memcpy
  89 ; CHECK: call void @g3(%struct.ss* %S1)
  90 ; CHECK: ret void
  91 }
  92
  93
  94 ; Inlining a byval struct should NOT cause an explicit copy
  95 ; into an alloca if the function is readonly, but should increase an alloca's
  96 ; alignment to satisfy an explicit alignment request.
  97
  98 define internal i32 @f4(%struct.ss* byval align 64 %b) nounwind readonly {
  99         call void @g3(%struct.ss* %b)
 100         ret i32 4
 101 }
 102
 103 define i32 @test4() nounwind  {
 104 entry:
 105         %S = alloca %struct.ss, align 2         ; <%struct.ss*> [#uses=4]
 106         %X = call i32 @f4( %struct.ss* byval align 64 %S ) nounwind
 107         ret i32 %X
 108 ; CHECK: @test4()
 109 ; CHECK: %S = alloca %struct.ss, align 64
 110 ; CHECK-NOT: call void @llvm.memcpy
 111 ; CHECK: call void @g3
 112 ; CHECK: ret i32 4
 113 }
 114
 115 %struct.S0 = type { i32 }
 116
 117 @b = global %struct.S0 { i32 1 }, align 4
 118 @a = common global i32 0, align 4
 119
 120 define internal void @f5(%struct.S0* byval nocapture readonly align 4 %p) {
 121 entry:
 122         store i32 0, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
 123         %f2 = getelementptr inbounds %struct.S0, %struct.S0* %p, i64 0, i32 0
 124         %0 = load i32, i32* %f2, align 4
 125         store i32 %0, i32* @a, align 4
 126         ret void
 127 }
 128
 129 define i32 @test5() {
 130 entry:
 131         tail call void @f5(%struct.S0* byval align 4 @b)
 132         %0 = load i32, i32* @a, align 4
 133         ret i32 %0
 134 ; CHECK: @test5()
 135 ; CHECK: store i32 0, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
 136 ; CHECK-NOT: load i32, i32* getelementptr inbounds (%struct.S0, %struct.S0* @b, i64 0, i32 0), align 4
 137 }
 138
 139 ; Inlining a byval struct that is in a different address space compared to the
 140 ; alloca address space is at the moment not expected. That would need
 141 ; adjustments inside the inlined function since the address space attribute of
 142 ; the inlined argument changes.
 143
 144 %struct.S1 = type { i32 }
 145
 146 @d = addrspace(1) global %struct.S1 { i32 1 }, align 4
 147 @c = common addrspace(1) global i32 0, align 4
 148
 149 define internal void @f5_as1(%struct.S1 addrspace(1)* byval nocapture readonly align 4 %p) {
 150 entry:
 151         store i32 0, i32 addrspace(1)* getelementptr inbounds (%struct.S1, %struct.S1 addrspace(1)* @d, i64 0, i32 0), align 4
 152         %f2 = getelementptr inbounds %struct.S1, %struct.S1 addrspace(1)* %p, i64 0, i32 0
 153         %0 = load i32, i32 addrspace(1)* %f2, align 4
 154         store i32 %0, i32 addrspace(1)* @c, align 4
 155         ret void
 156 }
 157
 158 define i32 @test5_as1() {
 159 entry:
 160         tail call void @f5_as1(%struct.S1 addrspace(1)* byval align 4 @d)
 161         %0 = load i32, i32 addrspace(1)* @c, align 4
 162         ret i32 %0
 163 ; CHECK: @test5_as1()
 164 ; CHECK: call void @f5_as1
 165 }