llvm/test/Transforms/InstCombine/call.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
   2 ; RUN: opt < %s -passes=instcombine -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(ptr)
   8
   9 define void @test1(ptr %A) {
  10 ; CHECK-LABEL: define void @test1
  11 ; CHECK-SAME: (ptr [[A:%.*]]) {
  12 ; CHECK-NEXT:    call void @test1a(ptr [[A]])
  13 ; CHECK-NEXT:    ret void
  14 ;
  15   call void @test1a( ptr %A )
  16   ret void
  17 }
  18
  19
  20 ; Should not do because of change in address space of the parameter
  21 define void @test1_as1_illegal(ptr addrspace(1) %A) {
  22 ; CHECK-LABEL: define void @test1_as1_illegal
  23 ; CHECK-SAME: (ptr addrspace(1) [[A:%.*]]) {
  24 ; CHECK-NEXT:    call void @test1a(ptr addrspace(1) [[A]])
  25 ; CHECK-NEXT:    ret void
  26 ;
  27   call void @test1a(ptr addrspace(1) %A)
  28   ret void
  29 }
  30
  31 ; Test1, but the argument has a different sized address-space
  32 declare void @test1a_as1(ptr addrspace(1))
  33
  34 ; This one is OK to perform
  35 define void @test1_as1(ptr addrspace(1) %A) {
  36 ; CHECK-LABEL: define void @test1_as1
  37 ; CHECK-SAME: (ptr addrspace(1) [[A:%.*]]) {
  38 ; CHECK-NEXT:    call void @test1a_as1(ptr addrspace(1) [[A]])
  39 ; CHECK-NEXT:    ret void
  40 ;
  41   call void @test1a_as1(ptr addrspace(1) %A )
  42   ret void
  43 }
  44
  45 ; More complex case, translate argument because of resolution.  This is safe
  46 ; because we have the body of the function
  47 define void @test2a(i8 %A) {
  48 ; CHECK-LABEL: define void @test2a
  49 ; CHECK-SAME: (i8 [[A:%.*]]) {
  50 ; CHECK-NEXT:    ret void
  51 ;
  52   ret void
  53 }
  54
  55 define i32 @test2(i32 %A) {
  56 ; CHECK-LABEL: define i32 @test2
  57 ; CHECK-SAME: (i32 [[A:%.*]]) {
  58 ; CHECK-NEXT:    call void @test2a(i32 [[A]])
  59 ; CHECK-NEXT:    ret i32 [[A]]
  60 ;
  61   call void @test2a( i32 %A )
  62   ret i32 %A
  63 }
  64
  65
  66 ; Resolving this should insert a cast from sbyte to int, following the C
  67 ; promotion rules.
  68 define void @test3a(i8, ...) {unreachable }
  69 ; CHECK-LABEL: define void @test3a
  70 ; CHECK-SAME: (i8 [[TMP0:%.*]], ...) {
  71 ; CHECK-NEXT:    unreachable
  72 ;
  73 define void @test3(i8 %A, i8 %B) {
  74   call void @test3a( i8 %A, i8 %B)
  75   ret void
  76 }
  77
  78 ; test conversion of return value...
  79 define i8 @test4a() {
  80 ; CHECK-LABEL: define i8 @test4a() {
  81 ; CHECK-NEXT:    ret i8 0
  82 ;
  83   ret i8 0
  84 }
  85
  86 define i32 @test4() {
  87 ; CHECK-LABEL: define i32 @test4() {
  88 ; CHECK-NEXT:    [[X:%.*]] = call i32 @test4a()
  89 ; CHECK-NEXT:    ret i32 [[X]]
  90 ;
  91   %X = call i32 @test4a( )            ; <i32> [#uses=1]
  92   ret i32 %X
  93 }
  94
  95 ; test conversion of return value... no value conversion occurs so we can do
  96 ; this with just a prototype...
  97 declare i32 @test5a()
  98
  99 define i32 @test5() {
 100 ; CHECK-LABEL: define i32 @test5() {
 101 ; CHECK-NEXT:    [[X:%.*]] = call i32 @test5a()
 102 ; CHECK-NEXT:    ret i32 [[X]]
 103 ;
 104   %X = call i32 @test5a( )                ; <i32> [#uses=1]
 105   ret i32 %X
 106 }
 107
 108 ; test addition of new arguments...
 109 declare i32 @test6a(i32)
 110
 111 define i32 @test6() {
 112 ; CHECK-LABEL: define i32 @test6() {
 113 ; CHECK-NEXT:    [[X:%.*]] = call i32 @test6a(i32 0)
 114 ; CHECK-NEXT:    ret i32 [[X]]
 115 ;
 116   %X = call i32 @test6a( )
 117   ret i32 %X
 118 }
 119
 120 ; test removal of arguments, only can happen with a function body
 121 define void @test7a() {
 122 ; CHECK-LABEL: define void @test7a() {
 123 ; CHECK-NEXT:    ret void
 124 ;
 125   ret void
 126 }
 127
 128 define void @test7() {
 129 ; CHECK-LABEL: define void @test7() {
 130 ; CHECK-NEXT:    call void @test7a()
 131 ; CHECK-NEXT:    ret void
 132 ;
 133   call void @test7a( i32 5 )
 134   ret void
 135 }
 136
 137
 138 ; rdar://7590304
 139 declare void @test8a()
 140
 141 define ptr @test8() personality ptr @__gxx_personality_v0 {
 142 ; CHECK-LABEL: define ptr @test8() personality ptr @__gxx_personality_v0 {
 143 ; CHECK-NEXT:    invoke void @test8a()
 144 ; CHECK-NEXT:    to label [[INVOKE_CONT:%.*]] unwind label [[TRY_HANDLER:%.*]]
 145 ; CHECK:       invoke.cont:
 146 ; CHECK-NEXT:    unreachable
 147 ; CHECK:       try.handler:
 148 ; CHECK-NEXT:    [[EXN:%.*]] = landingpad { ptr, i32 }
 149 ; CHECK-NEXT:    cleanup
 150 ; CHECK-NEXT:    ret ptr null
 151 ;
 152 ; Don't turn this into "unreachable": the callee and caller don't agree in
 153 ; calling conv, but the implementation of test8a may actually end up using the
 154 ; right calling conv.
 155   invoke void @test8a()
 156   to label %invoke.cont unwind label %try.handler
 157
 158 invoke.cont:                                      ; preds = %entry
 159   unreachable
 160
 161 try.handler:                                      ; preds = %entry
 162   %exn = landingpad {ptr, i32}
 163   cleanup
 164   ret ptr null
 165 }
 166
 167 declare i32 @__gxx_personality_v0(...)
 168
 169
 170 ; Don't turn this into a direct call, because test9x is just a prototype and
 171 ; doing so will make it varargs.
 172 ; rdar://9038601
 173 declare ptr @test9x(ptr, ptr, ...) noredzone
 174 define ptr @test9(ptr %arg, ptr %tmp3) nounwind ssp noredzone {
 175 ; CHECK-LABEL: define ptr @test9
 176 ; CHECK-SAME: (ptr [[ARG:%.*]], ptr [[TMP3:%.*]]) #[[ATTR1:[0-9]+]] {
 177 ; CHECK-NEXT:  entry:
 178 ; CHECK-NEXT:    [[CALL:%.*]] = call ptr @test9x(ptr [[ARG]], ptr [[TMP3]]) #[[ATTR2:[0-9]+]]
 179 ; CHECK-NEXT:    ret ptr [[CALL]]
 180 ;
 181 entry:
 182   %call = call ptr @test9x(ptr %arg, ptr %tmp3) noredzone
 183   ret ptr %call
 184 }
 185
 186
 187 ; Parameter that's a vector of pointers
 188 declare void @test10a(<2 x ptr>)
 189
 190 define void @test10(<2 x ptr> %A) {
 191 ; CHECK-LABEL: define void @test10
 192 ; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
 193 ; CHECK-NEXT:    call void @test10a(<2 x ptr> [[A]])
 194 ; CHECK-NEXT:    ret void
 195 ;
 196   call void @test10a(<2 x ptr> %A)
 197   ret void
 198 }
 199
 200 ; Don't transform because different address spaces
 201 declare void @test10a_mixed_as(<2 x ptr addrspace(1)>)
 202
 203 define void @test10_mixed_as(<2 x ptr> %A) {
 204 ; CHECK-LABEL: define void @test10_mixed_as
 205 ; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
 206 ; CHECK-NEXT:    call void @test10a_mixed_as(<2 x ptr> [[A]])
 207 ; CHECK-NEXT:    ret void
 208 ;
 209   call void @test10a_mixed_as(<2 x ptr> %A)
 210   ret void
 211 }
 212
 213 ; Return type that's a pointer
 214 define ptr @test11a() {
 215 ; CHECK-LABEL: define ptr @test11a() {
 216 ; CHECK-NEXT:    ret ptr null
 217 ;
 218   ret ptr zeroinitializer
 219 }
 220
 221 define ptr @test11() {
 222 ; CHECK-LABEL: define ptr @test11() {
 223 ; CHECK-NEXT:    [[X:%.*]] = call ptr @test11a()
 224 ; CHECK-NEXT:    ret ptr [[X]]
 225 ;
 226   %X = call ptr @test11a()
 227   ret ptr %X
 228 }
 229
 230 ; Return type that's a pointer with a different address space
 231 define ptr addrspace(1) @test11a_mixed_as() {
 232 ; CHECK-LABEL: define ptr addrspace(1) @test11a_mixed_as() {
 233 ; CHECK-NEXT:    ret ptr addrspace(1) null
 234 ;
 235   ret ptr addrspace(1) zeroinitializer
 236 }
 237
 238 define ptr @test11_mixed_as() {
 239 ; CHECK-LABEL: define ptr @test11_mixed_as() {
 240 ; CHECK-NEXT:    [[X:%.*]] = call ptr @test11a_mixed_as()
 241 ; CHECK-NEXT:    ret ptr [[X]]
 242 ;
 243   %X = call ptr @test11a_mixed_as()
 244   ret ptr %X
 245 }
 246
 247 ; Return type that's a vector of pointers
 248 define <2 x ptr> @test12a() {
 249 ; CHECK-LABEL: define <2 x ptr> @test12a() {
 250 ; CHECK-NEXT:    ret <2 x ptr> zeroinitializer
 251 ;
 252   ret <2 x ptr> zeroinitializer
 253 }
 254
 255 define <2 x ptr> @test12() {
 256 ; CHECK-LABEL: define <2 x ptr> @test12() {
 257 ; CHECK-NEXT:    [[X:%.*]] = call <2 x ptr> @test12a()
 258 ; CHECK-NEXT:    ret <2 x ptr> [[X]]
 259 ;
 260   %X = call <2 x ptr> @test12a()
 261   ret <2 x ptr> %X
 262 }
 263
 264 define <2 x ptr addrspace(1)> @test12a_mixed_as() {
 265 ; CHECK-LABEL: define <2 x ptr addrspace(1)> @test12a_mixed_as() {
 266 ; CHECK-NEXT:    ret <2 x ptr addrspace(1)> zeroinitializer
 267 ;
 268   ret <2 x ptr addrspace(1)> zeroinitializer
 269 }
 270
 271 define <2 x ptr> @test12_mixed_as() {
 272 ; CHECK-LABEL: define <2 x ptr> @test12_mixed_as() {
 273 ; CHECK-NEXT:    [[X:%.*]] = call <2 x ptr> @test12a_mixed_as()
 274 ; CHECK-NEXT:    ret <2 x ptr> [[X]]
 275 ;
 276   %X = call <2 x ptr> @test12a_mixed_as()
 277   ret <2 x ptr> %X
 278 }
 279
 280
 281 ; Mix parameter that's a vector of integers and pointers of the same size
 282 declare void @test13a(<2 x i64>)
 283
 284 define void @test13(<2 x ptr> %A) {
 285 ; CHECK-LABEL: define void @test13
 286 ; CHECK-SAME: (<2 x ptr> [[A:%.*]]) {
 287 ; CHECK-NEXT:    call void @test13a(<2 x ptr> [[A]])
 288 ; CHECK-NEXT:    ret void
 289 ;
 290   call void @test13a(<2 x ptr> %A)
 291   ret void
 292 }
 293
 294 ; Mix parameter that's a vector of integers and pointers of the same
 295 ; size, but the other way around
 296 declare void @test14a(<2 x ptr>)
 297
 298 define void @test14(<2 x i64> %A) {
 299 ; CHECK-LABEL: define void @test14
 300 ; CHECK-SAME: (<2 x i64> [[A:%.*]]) {
 301 ; CHECK-NEXT:    call void @test14a(<2 x i64> [[A]])
 302 ; CHECK-NEXT:    ret void
 303 ;
 304   call void @test14a(<2 x i64> %A)
 305   ret void
 306 }
 307
 308
 309 ; Return type that's a vector
 310 define <2 x i16> @test15a() {
 311 ; CHECK-LABEL: define <2 x i16> @test15a() {
 312 ; CHECK-NEXT:    ret <2 x i16> zeroinitializer
 313 ;
 314   ret <2 x i16> zeroinitializer
 315 }
 316
 317 define i32 @test15() {
 318 ; CHECK-LABEL: define i32 @test15() {
 319 ; CHECK-NEXT:    [[X:%.*]] = call <2 x i16> @test15a()
 320 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast <2 x i16> [[X]] to i32
 321 ; CHECK-NEXT:    ret i32 [[TMP1]]
 322 ;
 323   %X = call i32 @test15a( )
 324   ret i32 %X
 325 }
 326
 327 define i32 @test16a() {
 328 ; CHECK-LABEL: define i32 @test16a() {
 329 ; CHECK-NEXT:    ret i32 0
 330 ;
 331   ret i32 0
 332 }
 333
 334 define <2 x i16> @test16() {
 335 ; CHECK-LABEL: define <2 x i16> @test16() {
 336 ; CHECK-NEXT:    [[X:%.*]] = call i32 @test16a()
 337 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i32 [[X]] to <2 x i16>
 338 ; CHECK-NEXT:    ret <2 x i16> [[TMP1]]
 339 ;
 340   %X = call <2 x i16> @test16a( )
 341   ret <2 x i16> %X
 342 }
 343
 344 declare i32 @pr28655(i32 returned %V)
 345
 346 define i32 @test17() {
 347 ; CHECK-LABEL: define i32 @test17() {
 348 ; CHECK-NEXT:  entry:
 349 ; CHECK-NEXT:    [[C:%.*]] = call i32 @pr28655(i32 0)
 350 ; CHECK-NEXT:    ret i32 0
 351 ;
 352 entry:
 353   %C = call i32 @pr28655(i32 0)
 354   ret i32 %C
 355 }
 356
 357 define void @non_vararg(ptr, i32) {
 358 ; CHECK-LABEL: define void @non_vararg
 359 ; CHECK-SAME: (ptr [[TMP0:%.*]], i32 [[TMP1:%.*]]) {
 360 ; CHECK-NEXT:    ret void
 361 ;
 362   ret void
 363 }
 364
 365 define void @test_cast_to_vararg(ptr %this) {
 366 ; CHECK-LABEL: define void @test_cast_to_vararg
 367 ; CHECK-SAME: (ptr [[THIS:%.*]]) {
 368 ; CHECK-NEXT:    call void @non_vararg(ptr [[THIS]], i32 42)
 369 ; CHECK-NEXT:    ret void
 370 ;
 371   call void (ptr, ...) @non_vararg(ptr %this, i32 42)
 372   ret void
 373 }