llvm/test/Transforms/CallSiteSplitting/callsite-split-or-phi.ll

   1 ; RUN: opt < %s -passes=callsite-splitting -S | FileCheck %s
   2 ; RUN: opt < %s -passes='function(callsite-splitting)' -S | FileCheck %s
   3
   4 target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
   5 target triple = "aarch64"
   6
   7 ;CHECK-LABEL: @test_eq_eq
   8
   9 ;CHECK-LABEL: Header:
  10 ;CHECK: br i1 %tobool1, label %Header.split, label %TBB
  11 ;CHECK-LABEL: Header.split:
  12 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr null, i32 %v, i32 1)
  13 ;CHECK-LABEL: TBB:
  14 ;CHECK: br i1 %cmp, label %TBB.split, label %End
  15 ;CHECK-LABEL: TBB.split:
  16 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr nonnull %a, i32 1, i32 2)
  17 ;CHECK-LABEL: Tail
  18 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
  19 ;CHECK: ret i32 %[[MERGED]]
  20 define i32 @test_eq_eq(ptr %a, i32 %v) {
  21 Header:
  22   %tobool1 = icmp eq ptr %a, null
  23   br i1 %tobool1, label %Tail, label %TBB
  24
  25 TBB:
  26   %cmp = icmp eq i32 %v, 1
  27   br i1 %cmp, label %Tail, label %End
  28
  29 Tail:
  30   %p = phi i32[1,%Header], [2, %TBB]
  31   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
  32   ret i32 %r
  33
  34 End:
  35   ret i32 %v
  36 }
  37
  38 ;CHECK-LABEL: @test_eq_eq_eq
  39 ;CHECK-LABEL: Header2.split:
  40 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 %v, i32 10)
  41 ;CHECK-LABEL: TBB.split:
  42 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 1, i32 %p)
  43 ;CHECK-LABEL: Tail
  44 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
  45 ;CHECK: ret i32 %[[MERGED]]
  46 define i32 @test_eq_eq_eq(ptr %a, i32 %v, i32 %p) {
  47 Header:
  48   %tobool1 = icmp eq ptr %a, null
  49   br i1 %tobool1, label %Header2, label %End
  50
  51 Header2:
  52   %tobool2 = icmp eq i32 %p, 10
  53   br i1 %tobool2, label %Tail, label %TBB
  54
  55 TBB:
  56   %cmp = icmp eq i32 %v, 1
  57   br i1 %cmp, label %Tail, label %End
  58
  59 Tail:
  60   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
  61   ret i32 %r
  62
  63 End:
  64   ret i32 %v
  65 }
  66
  67 ;CHECK-LABEL: @test_eq_eq_eq_constrain_same_i32_arg
  68 ;CHECK-LABEL: Header2.split:
  69 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 222, i32 %p)
  70 ;CHECK-LABEL: TBB.split:
  71 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 333, i32 %p)
  72 ;CHECK-LABEL: Tail
  73 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
  74 ;CHECK: ret i32 %[[MERGED]]
  75 define i32 @test_eq_eq_eq_constrain_same_i32_arg(ptr %a, i32 %v, i32 %p) {
  76 Header:
  77   %tobool1 = icmp eq i32 %v, 111
  78   br i1 %tobool1, label %Header2, label %End
  79
  80 Header2:
  81   %tobool2 = icmp eq i32 %v, 222
  82   br i1 %tobool2, label %Tail, label %TBB
  83
  84 TBB:
  85   %cmp = icmp eq i32 %v, 333
  86   br i1 %cmp, label %Tail, label %End
  87
  88 Tail:
  89   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
  90   ret i32 %r
  91
  92 End:
  93   ret i32 %v
  94 }
  95
  96 ;CHECK-LABEL: @test_ne_eq
  97 ;CHECK-LABEL: Header.split:
  98 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 1)
  99 ;CHECK-LABEL: TBB.split:
 100 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr null, i32 1, i32 2)
 101 ;CHECK-LABEL: Tail
 102 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 103 ;CHECK: ret i32 %[[MERGED]]
 104 define i32 @test_ne_eq(ptr %a, i32 %v) {
 105 Header:
 106   %tobool1 = icmp ne ptr %a, null
 107   br i1 %tobool1, label %Tail, label %TBB
 108
 109 TBB:
 110   %cmp = icmp eq i32 %v, 1
 111   br i1 %cmp, label %Tail, label %End
 112
 113 Tail:
 114   %p = phi i32[1,%Header], [2, %TBB]
 115   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 116   ret i32 %r
 117
 118 End:
 119   ret i32 %v
 120 }
 121
 122 ;CHECK-LABEL: @test_ne_eq_ne
 123 ;CHECK-LABEL: Header2.split:
 124 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 10)
 125 ;CHECK-LABEL: TBB.split:
 126 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 %v, i32 %p)
 127 ;CHECK-LABEL: Tail
 128 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
 129 ;CHECK: ret i32 %[[MERGED]]
 130 define i32 @test_ne_eq_ne(ptr %a, i32 %v, i32 %p) {
 131 Header:
 132   %tobool1 = icmp ne ptr %a, null
 133   br i1 %tobool1, label %Header2, label %TBB
 134
 135 Header2:
 136   %tobool2 = icmp eq i32 %p, 10
 137   br i1 %tobool2, label %Tail, label %TBB
 138
 139 TBB:
 140   %cmp = icmp ne i32 %v, 1
 141   br i1 %cmp, label %Tail, label %End
 142
 143 Tail:
 144   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 145   ret i32 %r
 146
 147 End:
 148   ret i32 %v
 149 }
 150
 151 ;CHECK-LABEL: @test_ne_ne
 152 ;CHECK-LABEL: Header.split:
 153 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 1)
 154 ;CHECK-LABEL: TBB.split:
 155 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr null, i32 %v, i32 2)
 156 ;CHECK-LABEL: Tail
 157 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 158 ;CHECK: ret i32 %[[MERGED]]
 159 define i32 @test_ne_ne(ptr %a, i32 %v) {
 160 Header:
 161   %tobool1 = icmp ne ptr %a, null
 162   br i1 %tobool1, label %Tail, label %TBB
 163
 164 TBB:
 165   %cmp = icmp ne i32 %v, 1
 166   br i1 %cmp, label %Tail, label %End
 167
 168 Tail:
 169   %p = phi i32[1,%Header], [2, %TBB]
 170   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 171   ret i32 %r
 172
 173 End:
 174   ret i32 %v
 175 }
 176
 177 ;CHECK-LABEL: @test_ne_ne_ne_constrain_same_pointer_arg
 178 ;CHECK-LABEL: Header2.split:
 179 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 %p)
 180 ;CHECK-LABEL: TBB.split:
 181 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 %v, i32 %p)
 182 ;CHECK-LABEL: Tail
 183 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
 184 ;CHECK: ret i32 %[[MERGED]]
 185 define i32 @test_ne_ne_ne_constrain_same_pointer_arg(ptr %a, i32 %v, i32 %p, ptr %a2, ptr %a3) {
 186 Header:
 187   %tobool1 = icmp ne ptr %a, null
 188   br i1 %tobool1, label %Header2, label %TBB
 189
 190 Header2:
 191   %tobool2 = icmp ne ptr %a, %a2
 192   br i1 %tobool2, label %Tail, label %TBB
 193
 194 TBB:
 195   %cmp = icmp ne ptr %a, %a3
 196   br i1 %cmp, label %Tail, label %End
 197
 198 Tail:
 199   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 200   ret i32 %r
 201
 202 End:
 203   ret i32 %v
 204 }
 205
 206
 207
 208 ;CHECK-LABEL: @test_eq_eq_untaken
 209 ;CHECK-LABEL: Header.split:
 210 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 1)
 211 ;CHECK-LABEL: TBB.split:
 212 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr null, i32 1, i32 2)
 213 ;CHECK-LABEL: Tail
 214 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 215 ;CHECK: ret i32 %[[MERGED]]
 216 define i32 @test_eq_eq_untaken(ptr %a, i32 %v) {
 217 Header:
 218   %tobool1 = icmp eq ptr %a, null
 219   br i1 %tobool1, label %TBB, label %Tail
 220
 221 TBB:
 222   %cmp = icmp eq i32 %v, 1
 223   br i1 %cmp, label %Tail, label %End
 224
 225 Tail:
 226   %p = phi i32[1,%Header], [2, %TBB]
 227   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 228   ret i32 %r
 229
 230 End:
 231   ret i32 %v
 232 }
 233
 234 ;CHECK-LABEL: @test_eq_eq_eq_untaken
 235 ;CHECK-LABEL: Header2.split:
 236 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr nonnull %a, i32 %v, i32 10)
 237 ;CHECK-LABEL: TBB.split:
 238 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 1, i32 %p)
 239 ;CHECK-LABEL: Tail
 240 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
 241 ;CHECK: ret i32 %[[MERGED]]
 242 define i32 @test_eq_eq_eq_untaken(ptr %a, i32 %v, i32 %p) {
 243 Header:
 244   %tobool1 = icmp eq ptr %a, null
 245   br i1 %tobool1, label %TBB, label %Header2
 246
 247 Header2:
 248   %tobool2 = icmp eq i32 %p, 10
 249   br i1 %tobool2, label %Tail, label %TBB
 250
 251 TBB:
 252   %cmp = icmp eq i32 %v, 1
 253   br i1 %cmp, label %Tail, label %End
 254
 255 Tail:
 256   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 257   ret i32 %r
 258
 259 End:
 260   ret i32 %v
 261 }
 262
 263 ;CHECK-LABEL: @test_ne_eq_untaken
 264 ;CHECK-LABEL: Header.split:
 265 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr null, i32 %v, i32 1)
 266 ;CHECK-LABEL: TBB.split:
 267 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr nonnull %a, i32 1, i32 2)
 268 ;CHECK-LABEL: Tail
 269 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 270 ;CHECK: ret i32 %[[MERGED]]
 271 define i32 @test_ne_eq_untaken(ptr %a, i32 %v) {
 272 Header:
 273   %tobool1 = icmp ne ptr %a, null
 274   br i1 %tobool1, label %TBB, label %Tail
 275
 276 TBB:
 277   %cmp = icmp eq i32 %v, 1
 278   br i1 %cmp, label %Tail, label %End
 279
 280 Tail:
 281   %p = phi i32[1,%Header], [2, %TBB]
 282   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 283   ret i32 %r
 284
 285 End:
 286   ret i32 %v
 287 }
 288
 289 ;CHECK-LABEL: @test_ne_eq_ne_untaken
 290 ;CHECK-LABEL: Header2.split:
 291 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr null, i32 %v, i32 10)
 292 ;CHECK-LABEL: TBB.split:
 293 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 %v, i32 %p)
 294 ;CHECK-LABEL: Tail
 295 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header2.split ], [ %[[CALL2]], %TBB.split ]
 296 ;CHECK: ret i32 %[[MERGED]]
 297 define i32 @test_ne_eq_ne_untaken(ptr %a, i32 %v, i32 %p) {
 298 Header:
 299   %tobool1 = icmp ne ptr %a, null
 300   br i1 %tobool1, label %TBB, label %Header2
 301
 302 Header2:
 303   %tobool2 = icmp eq i32 %p, 10
 304   br i1 %tobool2, label %Tail, label %TBB
 305
 306 TBB:
 307   %cmp = icmp ne i32 %v, 1
 308   br i1 %cmp, label %Tail, label %End
 309
 310 Tail:
 311   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 312   ret i32 %r
 313
 314 End:
 315   ret i32 %v
 316 }
 317
 318 ;CHECK-LABEL: @test_ne_ne_untaken
 319 ;CHECK-LABEL: Header.split:
 320 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr null, i32 %v, i32 1)
 321 ;CHECK-LABEL: TBB.split:
 322 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr nonnull %a, i32 1, i32 2)
 323 ;CHECK-LABEL: Tail
 324 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 325 ;CHECK: ret i32 %[[MERGED]]
 326 define i32 @test_ne_ne_untaken(ptr %a, i32 %v) {
 327 Header:
 328   %tobool1 = icmp ne ptr %a, null
 329   br i1 %tobool1, label %TBB, label %Tail
 330
 331 TBB:
 332   %cmp = icmp ne i32 %v, 1
 333   br i1 %cmp, label %End, label %Tail
 334
 335 Tail:
 336   %p = phi i32[1,%Header], [2, %TBB]
 337   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 338   ret i32 %r
 339
 340 End:
 341   ret i32 %v
 342 }
 343
 344 ;CHECK-LABEL: @test_nonconst_const_phi
 345 ;CHECK-LABEL: Header.split:
 346 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 %v, i32 1)
 347 ;CHECK-LABEL: TBB.split:
 348 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 1, i32 2)
 349 ;CHECK-LABEL: Tail
 350 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 351 ;CHECK: ret i32 %[[MERGED]]
 352 define i32 @test_nonconst_const_phi(ptr %a, ptr %b, i32 %v) {
 353 Header:
 354   %tobool1 = icmp eq ptr %a, %b
 355   br i1 %tobool1, label %Tail, label %TBB
 356
 357 TBB:
 358   %cmp = icmp eq i32 %v, 1
 359   br i1 %cmp, label %Tail, label %End
 360
 361 Tail:
 362   %p = phi i32[1,%Header], [2, %TBB]
 363   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 364   ret i32 %r
 365
 366 End:
 367   ret i32 %v
 368 }
 369
 370 ;CHECK-LABEL: @test_nonconst_nonconst_phi
 371 ;CHECK-LABEL: Header.split:
 372 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 %v, i32 1)
 373 ;CHECK-LABEL: TBB.split:
 374 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 %v, i32 2)
 375 ;CHECK-LABEL: Tail
 376 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL2]], %TBB.split ], [ %[[CALL1]], %Header.split ]
 377 ;CHECK: ret i32 %[[MERGED]]
 378 define i32 @test_nonconst_nonconst_phi(ptr %a, ptr %b, i32 %v, i32 %v2) {
 379 Header:
 380   %tobool1 = icmp eq ptr %a, %b
 381   br i1 %tobool1, label %Tail, label %TBB
 382
 383 TBB:
 384   %cmp = icmp eq i32 %v, %v2
 385   br i1 %cmp, label %Tail, label %End
 386
 387 Tail:
 388   %p = phi i32[1,%Header], [2, %TBB]
 389   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 390   ret i32 %r
 391
 392 End:
 393   ret i32 %v
 394 }
 395
 396 ;CHECK-LABEL: @test_cfg_no_or_phi
 397 ;CHECK-LABEL: TBB0.split
 398 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 %v, i32 1)
 399 ;CHECK-LABEL: TBB1.split:
 400 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 %v, i32 2)
 401 ;CHECK-LABEL: Tail
 402 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL2]], %TBB1.split ], [ %[[CALL1]], %TBB0.split ]
 403 ;CHECK: ret i32 %[[MERGED]]
 404 define i32 @test_cfg_no_or_phi(ptr %a,  i32 %v, i1 %arg) {
 405 entry:
 406   br i1 %arg, label %TBB0, label %TBB1
 407 TBB0:
 408   br i1 %arg, label %Tail, label %End
 409 TBB1:
 410   br i1 %arg, label %Tail, label %End
 411 Tail:
 412   %p = phi i32[1,%TBB0], [2, %TBB1]
 413   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 414   ret i32 %r
 415 End:
 416   ret i32 %v
 417 }
 418
 419 ;CHECK-LABEL: @test_nonconst_nonconst_phi_noncost
 420 ;CHECK-NOT: Header.split:
 421 ;CHECK-NOT: TBB.split:
 422 ;CHECK-LABEL: Tail:
 423 ;CHECK: %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 424 ;CHECK: ret i32 %r
 425 define i32 @test_nonconst_nonconst_phi_noncost(ptr %a, ptr %b, i32 %v, i32 %v2) {
 426 Header:
 427   %tobool1 = icmp eq ptr %a, %b
 428   br i1 %tobool1, label %Tail, label %TBB
 429
 430 TBB:
 431   %cmp = icmp eq i32 %v, %v2
 432   br i1 %cmp, label %Tail, label %End
 433
 434 Tail:
 435   %p = phi i32[%v,%Header], [%v2, %TBB]
 436   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 437   ret i32 %r
 438
 439 End:
 440   ret i32 %v
 441 }
 442
 443 ;CHECK-LABEL: @test_3preds_constphi
 444 ;CHECK-NOT: Header.split:
 445 ;CHECK-NOT: TBB.split:
 446 ;CHECK-LABEL: Tail:
 447 ;CHECK: %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 448 ;CHECK: ret i32 %r
 449 define i32 @test_3preds_constphi(ptr %a, i32 %v, i1 %c1, i1 %c2, i1 %c3) {
 450 Header:
 451   br i1 %c1, label %Tail, label %TBB1
 452
 453 TBB1:
 454   br i1 %c2, label %Tail, label %TBB2
 455
 456 TBB2:
 457   br i1 %c3, label %Tail, label %End
 458
 459 Tail:
 460   %p = phi i32[1,%Header], [2, %TBB1], [3, %TBB2]
 461   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 462   ret i32 %r
 463
 464 End:
 465   ret i32 %v
 466 }
 467
 468 ;CHECK-LABEL: @test_indirectbr_phi
 469 ;CHECK-NOT: Header.split:
 470 ;CHECK-NOT: TBB.split:
 471 ;CHECK-LABEL: Tail:
 472 ;CHECK: %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 473 ;CHECK: ret i32 %r
 474 define i32 @test_indirectbr_phi(ptr %address, ptr %a, ptr %b, i32 %v) {
 475 Header:
 476    %indirect.goto.dest = select i1 undef, ptr blockaddress(@test_indirectbr_phi, %End), ptr %address
 477    indirectbr ptr %indirect.goto.dest, [label %TBB, label %Tail]
 478
 479 TBB:
 480   %indirect.goto.dest2 = select i1 undef, ptr blockaddress(@test_indirectbr_phi, %End), ptr %address
 481   indirectbr ptr %indirect.goto.dest2, [label %Tail, label %End]
 482
 483 Tail:
 484   %p = phi i32[1,%Header], [2, %TBB]
 485   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 486   ret i32 %r
 487
 488 End:
 489   ret i32 %v
 490 }
 491
 492 ;CHECK-LABEL: @test_cond_no_effect
 493 ;CHECK-NOT: Header.split:
 494 ;CHECK-NOT: TBB.split:
 495 ;CHECK-LABEL: Tail:
 496 ;CHECK: %r = call i32 @callee(ptr %a, i32 %v, i32 0)
 497 ;CHECK: ret i32 %r
 498 define i32 @test_cond_no_effect(ptr %a, i32 %v, i1 %arg) {
 499 Entry:
 500   %tobool1 = icmp eq ptr %a, null
 501   br i1 %tobool1, label %Header, label %End
 502
 503 Header:
 504   br i1 %arg, label %Tail, label %TBB
 505
 506 TBB:
 507   br i1 %arg, label %Tail, label %End
 508
 509 Tail:
 510   %r = call i32 @callee(ptr %a, i32 %v, i32 0)
 511   ret i32 %r
 512
 513 End:
 514   ret i32 %v
 515 }
 516
 517 ;CHECK-LABEL: @test_unreachable
 518 ;CHECK-LABEL: Header.split:
 519 ;CHECK: %[[CALL1:.*]] = call i32 @callee(ptr %a, i32 %v, i32 10)
 520 ;CHECK-LABEL: TBB.split:
 521 ;CHECK: %[[CALL2:.*]] = call i32 @callee(ptr %a, i32 1, i32 %p)
 522 ;CHECK-LABEL: Tail
 523 ;CHECK: %[[MERGED:.*]] = phi i32 [ %[[CALL1]], %Header.split ], [ %[[CALL2]], %TBB.split ]
 524 ;CHECK: ret i32 %[[MERGED]]
 525 define i32 @test_unreachable(ptr %a, i32 %v, i32 %p) {
 526 Entry:
 527   br label %End
 528 Header:
 529   %tobool2 = icmp eq i32 %p, 10
 530   br i1 %tobool2, label %Tail, label %TBB
 531 TBB:
 532   %cmp = icmp eq i32 %v, 1
 533   br i1 %cmp, label %Tail, label %Header
 534 Tail:
 535   %r = call i32 @callee(ptr %a, i32 %v, i32 %p)
 536   ret i32 %r
 537 End:
 538   ret i32 %v
 539 }
 540
 541 define i32 @callee(ptr %a, i32 %v, i32 %p) {
 542 entry:
 543   %c = icmp ne ptr %a, null
 544   br i1 %c, label %BB1, label %BB2
 545
 546 BB1:
 547   call void @dummy(ptr %a, i32 %p)
 548   br label %End
 549
 550 BB2:
 551   call void @dummy2(i32 %v, i32 %p)
 552   br label %End
 553
 554 End:
 555   ret i32 %p
 556 }
 557
 558 declare void @dummy(ptr, i32)
 559 declare void @dummy2(i32, i32)
 560
 561 ; Make sure we remove the non-nullness on constant paramater.
 562 ;
 563 ;CHECK-LABEL: @caller2
 564 ;CHECK-LABEL: Top1.split:
 565 ;CHECK: call i32 @callee(ptr inttoptr (i64 4643 to ptr)
 566 define void @caller2(i32 %c, ptr %a_elt, ptr %b_elt) {
 567 entry:
 568   br label %Top0
 569
 570 Top0:
 571   %tobool1 = icmp eq ptr %a_elt, inttoptr (i64 4643 to  ptr)
 572   br i1 %tobool1, label %Top1, label %NextCond
 573
 574 Top1:
 575   %tobool2 = icmp ne ptr %a_elt, null
 576   br i1 %tobool2, label %CallSiteBB, label %NextCond
 577
 578 NextCond:
 579   %cmp = icmp ne ptr %b_elt, null
 580   br i1 %cmp, label %CallSiteBB, label %End
 581
 582 CallSiteBB:
 583   call i32 @callee(ptr %a_elt, i32 %c, i32 %c)
 584   br label %End
 585
 586 End:
 587   ret void
 588 }
 589
 590 ; CHECK-LABEL: i32 @test_multiple_phis(
 591 ; CHECK:      Header.split:
 592 ; CHECK-NEXT:   %r2 = call i32 @callee(ptr null, i32 1, i32 5)
 593 ; CHECK-NEXT:   br label %Tail
 594
 595 ; CHECK:      TBB.split:
 596 ; CHECK-NEXT:   %r1 = call i32 @callee(ptr null, i32 2, i32 10)
 597 ; CHECK-NEXT:   br label %Tail
 598
 599 ; CHECK:        Tail:
 600 ; CHECK-NEXT:   %phi.call = phi i32 [ %r1, %TBB.split ], [ %r2, %Header.split ]
 601 ; CHECK-NEXT:   %p.0 = phi i32 [ 0, %Header.split ], [ 99, %TBB.split ]
 602 ; CHECK-NEXT:   %res = add i32 %phi.call, %p.0
 603 ; CHECK-NEXT:   ret i32 %phi.call
 604 ;
 605 define i32 @test_multiple_phis(i1 %c.1) {
 606 Header:
 607   br i1 %c.1, label %Tail, label %TBB
 608
 609 TBB:
 610   br label %Tail
 611
 612 Tail:
 613   %p.0 = phi i32 [0, %Header], [99, %TBB]
 614   %p.1 = phi i32[1, %Header], [2, %TBB]
 615   %p.2 = phi i32 [5, %Header], [10, %TBB]
 616   %r = call i32 @callee(ptr null, i32 %p.1, i32 %p.2)
 617   %res = add i32 %r, %p.0
 618   ret i32 %r
 619
 620 End:
 621   ret i32 10
 622 }