test/Transforms/InstCombine/call.ll

   1 ; Ignore stderr, we expect warnings there
   2 ; RUN: opt < %s -instcombine 2> /dev/null -S | FileCheck %s
   3
   4 target datalayout = "E-p:64:64:64-p1:16:16:16-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
   5
   6 ; Simple case, argument translatable without changing the value
   7 declare void @test1a(i8*)
   8
   9 define void @test1(i32* %A) {
  10 ; CHECK-LABEL: @test1(
  11 ; CHECK: %1 = bitcast i32* %A to i8*
  12 ; CHECK: call void @test1a(i8* %1)
  13 ; CHECK: ret void
  14   call void bitcast (void (i8*)* @test1a to void (i32*)*)( i32* %A )
  15   ret void
  16 }
  17
  18
  19 ; Should not do because of change in address space of the parameter
  20 define void @test1_as1_illegal(i32 addrspace(1)* %A) {
  21 ; CHECK-LABEL: @test1_as1_illegal(
  22 ; CHECK: call void bitcast
  23   call void bitcast (void (i8*)* @test1a to void (i32 addrspace(1)*)*)(i32 addrspace(1)* %A)
  24   ret void
  25 }
  26
  27 ; Test1, but the argument has a different sized address-space
  28 declare void @test1a_as1(i8 addrspace(1)*)
  29
  30 ; This one is OK to perform
  31 define void @test1_as1(i32 addrspace(1)* %A) {
  32 ; CHECK-LABEL: @test1_as1(
  33 ; CHECK: %1 = bitcast i32 addrspace(1)* %A to i8 addrspace(1)*
  34 ; CHECK: call void @test1a_as1(i8 addrspace(1)* %1)
  35 ; CHECK: ret void
  36   call void bitcast (void (i8 addrspace(1)*)* @test1a_as1 to void (i32 addrspace(1)*)*)(i32 addrspace(1)* %A )
  37   ret void
  38 }
  39
  40 ; More complex case, translate argument because of resolution.  This is safe
  41 ; because we have the body of the function
  42 define void @test2a(i8 %A) {
  43 ; CHECK-LABEL: @test2a(
  44 ; CHECK: ret void
  45   ret void
  46 }
  47
  48 define i32 @test2(i32 %A) {
  49 ; CHECK-LABEL: @test2(
  50 ; CHECK: call void bitcast
  51 ; CHECK: ret i32 %A
  52   call void bitcast (void (i8)* @test2a to void (i32)*)( i32 %A )
  53   ret i32 %A
  54 }
  55
  56
  57 ; Resolving this should insert a cast from sbyte to int, following the C
  58 ; promotion rules.
  59 define void @test3a(i8, ...) {unreachable }
  60
  61 define void @test3(i8 %A, i8 %B) {
  62 ; CHECK-LABEL: @test3(
  63 ; CHECK: %1 = zext i8 %B to i32
  64 ; CHECK: call void (i8, ...) @test3a(i8 %A, i32 %1)
  65 ; CHECK: ret void
  66   call void bitcast (void (i8, ...)* @test3a to void (i8, i8)*)( i8 %A, i8 %B)
  67   ret void
  68 }
  69
  70 ; test conversion of return value...
  71 define i8 @test4a() {
  72 ; CHECK-LABEL: @test4a(
  73 ; CHECK: ret i8 0
  74   ret i8 0
  75 }
  76
  77 define i32 @test4() {
  78 ; CHECK-LABEL: @test4(
  79 ; CHECK: call i32 bitcast
  80   %X = call i32 bitcast (i8 ()* @test4a to i32 ()*)( )            ; <i32> [#uses=1]
  81   ret i32 %X
  82 }
  83
  84 ; test conversion of return value... no value conversion occurs so we can do
  85 ; this with just a prototype...
  86 declare i32 @test5a()
  87
  88 define i32 @test5() {
  89 ; CHECK-LABEL: @test5(
  90 ; CHECK: %X = call i32 @test5a()
  91 ; CHECK: ret i32 %X
  92   %X = call i32 @test5a( )                ; <i32> [#uses=1]
  93   ret i32 %X
  94 }
  95
  96 ; test addition of new arguments...
  97 declare i32 @test6a(i32)
  98
  99 define i32 @test6() {
 100 ; CHECK-LABEL: @test6(
 101 ; CHECK: %X = call i32 @test6a(i32 0)
 102 ; CHECK: ret i32 %X
 103   %X = call i32 bitcast (i32 (i32)* @test6a to i32 ()*)( )
 104   ret i32 %X
 105 }
 106
 107 ; test removal of arguments, only can happen with a function body
 108 define void @test7a() {
 109 ; CHECK-LABEL: @test7a(
 110 ; CHECK: ret void
 111   ret void
 112 }
 113
 114 define void @test7() {
 115 ; CHECK-LABEL: @test7(
 116 ; CHECK: call void @test7a()
 117 ; CHECK: ret void
 118   call void bitcast (void ()* @test7a to void (i32)*)( i32 5 )
 119   ret void
 120 }
 121
 122
 123 ; rdar://7590304
 124 declare void @test8a()
 125
 126 define i8* @test8() personality i32 (...)* @__gxx_personality_v0 {
 127 ; CHECK-LABEL: @test8(
 128 ; CHECK-NEXT: invoke void @test8a()
 129 ; Don't turn this into "unreachable": the callee and caller don't agree in
 130 ; calling conv, but the implementation of test8a may actually end up using the
 131 ; right calling conv.
 132   invoke void @test8a()
 133           to label %invoke.cont unwind label %try.handler
 134
 135 invoke.cont:                                      ; preds = %entry
 136   unreachable
 137
 138 try.handler:                                      ; preds = %entry
 139   %exn = landingpad {i8*, i32}
 140             cleanup
 141   ret i8* null
 142 }
 143
 144 declare i32 @__gxx_personality_v0(...)
 145
 146
 147 ; Don't turn this into a direct call, because test9x is just a prototype and
 148 ; doing so will make it varargs.
 149 ; rdar://9038601
 150 declare i8* @test9x(i8*, i8*, ...) noredzone
 151 define i8* @test9(i8* %arg, i8* %tmp3) nounwind ssp noredzone {
 152 ; CHECK-LABEL: @test9
 153 entry:
 154   %call = call i8* bitcast (i8* (i8*, i8*, ...)* @test9x to i8* (i8*, i8*)*)(i8* %arg, i8* %tmp3) noredzone
 155   ret i8* %call
 156 ; CHECK-LABEL: @test9(
 157 ; CHECK: call i8* bitcast
 158 }
 159
 160
 161 ; Parameter that's a vector of pointers
 162 declare void @test10a(<2 x i8*>)
 163
 164 define void @test10(<2 x i32*> %A) {
 165 ; CHECK-LABEL: @test10(
 166 ; CHECK: %1 = bitcast <2 x i32*> %A to <2 x i8*>
 167 ; CHECK: call void @test10a(<2 x i8*> %1)
 168 ; CHECK: ret void
 169   call void bitcast (void (<2 x i8*>)* @test10a to void (<2 x i32*>)*)(<2 x i32*> %A)
 170   ret void
 171 }
 172
 173 ; Don't transform because different address spaces
 174 declare void @test10a_mixed_as(<2 x i8 addrspace(1)*>)
 175
 176 define void @test10_mixed_as(<2 x i8*> %A) {
 177 ; CHECK-LABEL: @test10_mixed_as(
 178 ; CHECK: call void bitcast
 179   call void bitcast (void (<2 x i8 addrspace(1)*>)* @test10a_mixed_as to void (<2 x i8*>)*)(<2 x i8*> %A)
 180   ret void
 181 }
 182
 183 ; Return type that's a pointer
 184 define i8* @test11a() {
 185   ret i8* zeroinitializer
 186 }
 187
 188 define i32* @test11() {
 189 ; CHECK-LABEL: @test11(
 190 ; CHECK: %X = call i8* @test11a()
 191 ; CHECK: %1 = bitcast i8* %X to i32*
 192   %X = call i32* bitcast (i8* ()* @test11a to i32* ()*)()
 193   ret i32* %X
 194 }
 195
 196 ; Return type that's a pointer with a different address space
 197 define i8 addrspace(1)* @test11a_mixed_as() {
 198   ret i8 addrspace(1)* zeroinitializer
 199 }
 200
 201 define i8* @test11_mixed_as() {
 202 ; CHECK-LABEL: @test11_mixed_as(
 203 ; CHECK: call i8* bitcast
 204   %X = call i8* bitcast (i8 addrspace(1)* ()* @test11a_mixed_as to i8* ()*)()
 205   ret i8* %X
 206 }
 207
 208 ; Return type that's a vector of pointers
 209 define <2 x i8*> @test12a() {
 210   ret <2 x i8*> zeroinitializer
 211 }
 212
 213 define <2 x i32*> @test12() {
 214 ; CHECK-LABEL: @test12(
 215 ; CHECK: %X = call <2 x i8*> @test12a()
 216 ; CHECK: %1 = bitcast <2 x i8*> %X to <2 x i32*>
 217   %X = call <2 x i32*> bitcast (<2 x i8*> ()* @test12a to <2 x i32*> ()*)()
 218   ret <2 x i32*> %X
 219 }
 220
 221 define <2 x i8 addrspace(1)*> @test12a_mixed_as() {
 222   ret <2 x i8 addrspace(1)*> zeroinitializer
 223 }
 224
 225 define <2 x i8*> @test12_mixed_as() {
 226 ; CHECK-LABEL: @test12_mixed_as(
 227 ; CHECK: call <2 x i8*> bitcast
 228   %X = call <2 x i8*> bitcast (<2 x i8 addrspace(1)*> ()* @test12a_mixed_as to <2 x i8*> ()*)()
 229   ret <2 x i8*> %X
 230 }
 231
 232
 233 ; Mix parameter that's a vector of integers and pointers of the same size
 234 declare void @test13a(<2 x i64>)
 235
 236 define void @test13(<2 x i32*> %A) {
 237 ; CHECK-LABEL: @test13(
 238 ; CHECK: call void bitcast
 239   call void bitcast (void (<2 x i64>)* @test13a to void (<2 x i32*>)*)(<2 x i32*> %A)
 240   ret void
 241 }
 242
 243 ; Mix parameter that's a vector of integers and pointers of the same
 244 ; size, but the other way around
 245 declare void @test14a(<2 x i8*>)
 246
 247 define void @test14(<2 x i64> %A) {
 248 ; CHECK-LABEL: @test14(
 249 ; CHECK: call void bitcast
 250   call void bitcast (void (<2 x i8*>)* @test14a to void (<2 x i64>)*)(<2 x i64> %A)
 251   ret void
 252 }
 253
 254
 255 ; Return type that's a vector
 256 define <2 x i16> @test15a() {
 257   ret <2 x i16> zeroinitializer
 258 }
 259
 260 define i32 @test15() {
 261 ; CHECK-LABEL: @test15(
 262 ; CHECK: %X = call <2 x i16> @test15a()
 263 ; CHECK: %1 = bitcast <2 x i16> %X to i32
 264   %X = call i32 bitcast (<2 x i16> ()* @test15a to i32 ()*)( )
 265   ret i32 %X
 266 }
 267
 268 define i32 @test16a() {
 269   ret i32 0
 270 }
 271
 272 define <2 x i16> @test16() {
 273 ; CHECK-LABEL: @test16(
 274 ; CHECK: %X = call i32 @test16a()
 275 ; CHECK: %1 = bitcast i32 %X to <2 x i16>
 276   %X = call <2 x i16> bitcast (i32 ()* @test16a to <2 x i16> ()*)( )
 277   ret <2 x i16> %X
 278 }