llvm/test/Transforms/InstCombine/assume.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -instcombine -S  -instcombine-infinite-loop-threshold=2  | FileCheck --check-prefixes=CHECK,DEFAULT %s
   3 ; RUN: opt < %s -instcombine --enable-knowledge-retention -S  -instcombine-infinite-loop-threshold=2  | FileCheck --check-prefixes=CHECK,BUNDLES %s
   4
   5 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   6 target triple = "x86_64-unknown-linux-gnu"
   7
   8 declare void @llvm.assume(i1) #1
   9
  10 ; Check that the alignment has been upgraded and that the assume has not
  11 ; been removed:
  12
  13 define i32 @foo1(i32* %a) #0 {
  14 ; DEFAULT-LABEL: @foo1(
  15 ; DEFAULT-NEXT:    [[T0:%.*]] = load i32, i32* [[A:%.*]], align 32
  16 ; DEFAULT-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[A]] to i64
  17 ; DEFAULT-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
  18 ; DEFAULT-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
  19 ; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[MASKCOND]])
  20 ; DEFAULT-NEXT:    ret i32 [[T0]]
  21 ;
  22 ; BUNDLES-LABEL: @foo1(
  23 ; BUNDLES-NEXT:    [[T0:%.*]] = load i32, i32* [[A:%.*]], align 32
  24 ; BUNDLES-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[A]], i64 32) ]
  25 ; BUNDLES-NEXT:    ret i32 [[T0]]
  26 ;
  27   %t0 = load i32, i32* %a, align 4
  28   %ptrint = ptrtoint i32* %a to i64
  29   %maskedptr = and i64 %ptrint, 31
  30   %maskcond = icmp eq i64 %maskedptr, 0
  31   tail call void @llvm.assume(i1 %maskcond)
  32   ret i32 %t0
  33 }
  34
  35 ; Same check as in @foo1, but make sure it works if the assume is first too.
  36
  37 define i32 @foo2(i32* %a) #0 {
  38 ; DEFAULT-LABEL: @foo2(
  39 ; DEFAULT-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[A:%.*]] to i64
  40 ; DEFAULT-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
  41 ; DEFAULT-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
  42 ; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[MASKCOND]])
  43 ; DEFAULT-NEXT:    [[T0:%.*]] = load i32, i32* [[A]], align 32
  44 ; DEFAULT-NEXT:    ret i32 [[T0]]
  45 ;
  46 ; BUNDLES-LABEL: @foo2(
  47 ; BUNDLES-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[A:%.*]], i64 32) ]
  48 ; BUNDLES-NEXT:    [[T0:%.*]] = load i32, i32* [[A]], align 32
  49 ; BUNDLES-NEXT:    ret i32 [[T0]]
  50 ;
  51   %ptrint = ptrtoint i32* %a to i64
  52   %maskedptr = and i64 %ptrint, 31
  53   %maskcond = icmp eq i64 %maskedptr, 0
  54   tail call void @llvm.assume(i1 %maskcond)
  55   %t0 = load i32, i32* %a, align 4
  56   ret i32 %t0
  57 }
  58
  59 define i32 @simple(i32 %a) #1 {
  60 ; CHECK-LABEL: @simple(
  61 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A:%.*]], 4
  62 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
  63 ; CHECK-NEXT:    ret i32 4
  64 ;
  65   %cmp = icmp eq i32 %a, 4
  66   tail call void @llvm.assume(i1 %cmp)
  67   ret i32 %a
  68 }
  69
  70 define i32 @can1(i1 %a, i1 %b, i1 %c) {
  71 ; CHECK-LABEL: @can1(
  72 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A:%.*]])
  73 ; CHECK-NEXT:    call void @llvm.assume(i1 [[B:%.*]])
  74 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C:%.*]])
  75 ; CHECK-NEXT:    ret i32 5
  76 ;
  77   %and1 = and i1 %a, %b
  78   %and  = and i1 %and1, %c
  79   tail call void @llvm.assume(i1 %and)
  80   ret i32 5
  81 }
  82
  83 define i32 @can1_logical(i1 %a, i1 %b, i1 %c) {
  84 ; CHECK-LABEL: @can1_logical(
  85 ; CHECK-NEXT:    call void @llvm.assume(i1 [[A:%.*]])
  86 ; CHECK-NEXT:    call void @llvm.assume(i1 [[B:%.*]])
  87 ; CHECK-NEXT:    call void @llvm.assume(i1 [[C:%.*]])
  88 ; CHECK-NEXT:    ret i32 5
  89 ;
  90   %and1 = select i1 %a, i1 %b, i1 false
  91   %and  = select i1 %and1, i1 %c, i1 false
  92   tail call void @llvm.assume(i1 %and)
  93   ret i32 5
  94 }
  95
  96 define i32 @can2(i1 %a, i1 %b, i1 %c) {
  97 ; CHECK-LABEL: @can2(
  98 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
  99 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP1]])
 100 ; CHECK-NEXT:    [[TMP2:%.*]] = xor i1 [[B:%.*]], true
 101 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP2]])
 102 ; CHECK-NEXT:    ret i32 5
 103 ;
 104   %v = or i1 %a, %b
 105   %w = xor i1 %v, 1
 106   tail call void @llvm.assume(i1 %w)
 107   ret i32 5
 108 }
 109
 110 define i32 @can2_logical(i1 %a, i1 %b, i1 %c) {
 111 ; CHECK-LABEL: @can2_logical(
 112 ; CHECK-NEXT:    [[TMP1:%.*]] = xor i1 [[A:%.*]], true
 113 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP1]])
 114 ; CHECK-NEXT:    [[TMP2:%.*]] = xor i1 [[B:%.*]], true
 115 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP2]])
 116 ; CHECK-NEXT:    ret i32 5
 117 ;
 118   %v = select i1 %a, i1 true, i1 %b
 119   %w = xor i1 %v, 1
 120   tail call void @llvm.assume(i1 %w)
 121   ret i32 5
 122 }
 123
 124 define i32 @bar1(i32 %a) #0 {
 125 ; CHECK-LABEL: @bar1(
 126 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], 7
 127 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 1
 128 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 129 ; CHECK-NEXT:    ret i32 1
 130 ;
 131   %and1 = and i32 %a, 3
 132   %and = and i32 %a, 7
 133   %cmp = icmp eq i32 %and, 1
 134   tail call void @llvm.assume(i1 %cmp)
 135   ret i32 %and1
 136 }
 137
 138 define i32 @bar2(i32 %a) #0 {
 139 ; CHECK-LABEL: @bar2(
 140 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], 7
 141 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 1
 142 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 143 ; CHECK-NEXT:    ret i32 1
 144 ;
 145   %and = and i32 %a, 7
 146   %cmp = icmp eq i32 %and, 1
 147   tail call void @llvm.assume(i1 %cmp)
 148   %and1 = and i32 %a, 3
 149   ret i32 %and1
 150 }
 151
 152 define i32 @bar3(i32 %a, i1 %x, i1 %y) #0 {
 153 ; CHECK-LABEL: @bar3(
 154 ; CHECK-NEXT:  entry:
 155 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[X:%.*]])
 156 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], 7
 157 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 1
 158 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 159 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[Y:%.*]])
 160 ; CHECK-NEXT:    ret i32 1
 161 ;
 162 entry:
 163   %and1 = and i32 %a, 3
 164
 165 ; Don't be fooled by other assumes around.
 166
 167   tail call void @llvm.assume(i1 %x)
 168
 169   %and = and i32 %a, 7
 170   %cmp = icmp eq i32 %and, 1
 171   tail call void @llvm.assume(i1 %cmp)
 172
 173   tail call void @llvm.assume(i1 %y)
 174
 175   ret i32 %and1
 176 }
 177
 178 ; If we allow recursive known bits queries based on
 179 ; assumptions, we could do better here:
 180 ; a == b and a & 7 == 1, so b & 7 == 1, so b & 3 == 1, so return 1.
 181
 182 define i32 @known_bits_recursion_via_assumes(i32 %a, i32 %b) {
 183 ; CHECK-LABEL: @known_bits_recursion_via_assumes(
 184 ; CHECK-NEXT:  entry:
 185 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], 3
 186 ; CHECK-NEXT:    [[AND:%.*]] = and i32 [[A:%.*]], 7
 187 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[AND]], 1
 188 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 189 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[A]], [[B]]
 190 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP2]])
 191 ; CHECK-NEXT:    ret i32 [[AND1]]
 192 ;
 193 entry:
 194   %and1 = and i32 %b, 3
 195   %and = and i32 %a, 7
 196   %cmp = icmp eq i32 %and, 1
 197   tail call void @llvm.assume(i1 %cmp)
 198   %cmp2 = icmp eq i32 %a, %b
 199   tail call void @llvm.assume(i1 %cmp2)
 200   ret i32 %and1
 201 }
 202
 203 define i32 @icmp1(i32 %a) #0 {
 204 ; CHECK-LABEL: @icmp1(
 205 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5
 206 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 207 ; CHECK-NEXT:    ret i32 1
 208 ;
 209   %cmp = icmp sgt i32 %a, 5
 210   tail call void @llvm.assume(i1 %cmp)
 211   %conv = zext i1 %cmp to i32
 212   ret i32 %conv
 213 }
 214
 215 define i32 @icmp2(i32 %a) #0 {
 216 ; CHECK-LABEL: @icmp2(
 217 ; CHECK-NEXT:    [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5
 218 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 219 ; CHECK-NEXT:    ret i32 0
 220 ;
 221   %cmp = icmp sgt i32 %a, 5
 222   tail call void @llvm.assume(i1 %cmp)
 223   %t0 = zext i1 %cmp to i32
 224   %lnot.ext = xor i32 %t0, 1
 225   ret i32 %lnot.ext
 226 }
 227
 228 ; If the 'not' of a condition is known true, then the condition must be false.
 229
 230 define i1 @assume_not(i1 %cond) {
 231 ; CHECK-LABEL: @assume_not(
 232 ; CHECK-NEXT:    [[NOTCOND:%.*]] = xor i1 [[COND:%.*]], true
 233 ; CHECK-NEXT:    call void @llvm.assume(i1 [[NOTCOND]])
 234 ; CHECK-NEXT:    ret i1 false
 235 ;
 236   %notcond = xor i1 %cond, true
 237   call void @llvm.assume(i1 %notcond)
 238   ret i1 %cond
 239 }
 240
 241 declare void @escape(i32* %a)
 242
 243 ; Canonicalize a nonnull assumption on a load into metadata form.
 244
 245 define i32 @bundle1(i32* %P) {
 246 ; CHECK-LABEL: @bundle1(
 247 ; CHECK-NEXT:    tail call void @llvm.assume(i1 true) [ "nonnull"(i32* [[P:%.*]]) ]
 248 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[P]], align 4
 249 ; CHECK-NEXT:    ret i32 [[LOAD]]
 250 ;
 251   tail call void @llvm.assume(i1 true) ["nonnull"(i32* %P)]
 252   %load = load i32, i32* %P
 253   ret i32 %load
 254 }
 255
 256 define i32 @bundle2(i32* %P) {
 257 ; CHECK-LABEL: @bundle2(
 258 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[P:%.*]], align 4
 259 ; CHECK-NEXT:    ret i32 [[LOAD]]
 260 ;
 261   tail call void @llvm.assume(i1 true) ["ignore"(i32* undef)]
 262   %load = load i32, i32* %P
 263   ret i32 %load
 264 }
 265
 266 define i1 @nonnull1(i32** %a) {
 267 ; CHECK-LABEL: @nonnull1(
 268 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8, !nonnull !6
 269 ; CHECK-NEXT:    tail call void @escape(i32* nonnull [[LOAD]])
 270 ; CHECK-NEXT:    ret i1 false
 271 ;
 272   %load = load i32*, i32** %a
 273   %cmp = icmp ne i32* %load, null
 274   tail call void @llvm.assume(i1 %cmp)
 275   tail call void @escape(i32* %load)
 276   %rval = icmp eq i32* %load, null
 277   ret i1 %rval
 278 }
 279
 280 ; Make sure the above canonicalization applies only
 281 ; to pointer types.  Doing otherwise would be illegal.
 282
 283 define i1 @nonnull2(i32* %a) {
 284 ; CHECK-LABEL: @nonnull2(
 285 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, i32* [[A:%.*]], align 4
 286 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32 [[LOAD]], 0
 287 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 288 ; CHECK-NEXT:    ret i1 false
 289 ;
 290   %load = load i32, i32* %a
 291   %cmp = icmp ne i32 %load, 0
 292   tail call void @llvm.assume(i1 %cmp)
 293   %rval = icmp eq i32 %load, 0
 294   ret i1 %rval
 295 }
 296
 297 ; Make sure the above canonicalization does not trigger
 298 ; if the assume is control dependent on something else
 299
 300 define i1 @nonnull3(i32** %a, i1 %control) {
 301 ; FIXME: in the BUNDLES version we could duplicate the load and keep the assume nonnull.
 302 ; DEFAULT-LABEL: @nonnull3(
 303 ; DEFAULT-NEXT:  entry:
 304 ; DEFAULT-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 305 ; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 306 ; DEFAULT-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 307 ; DEFAULT:       taken:
 308 ; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 309 ; DEFAULT-NEXT:    ret i1 false
 310 ; DEFAULT:       not_taken:
 311 ; DEFAULT-NEXT:    [[RVAL_2:%.*]] = icmp sgt i32* [[LOAD]], null
 312 ; DEFAULT-NEXT:    ret i1 [[RVAL_2]]
 313 ;
 314 ; BUNDLES-LABEL: @nonnull3(
 315 ; BUNDLES-NEXT:  entry:
 316 ; BUNDLES-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 317 ; BUNDLES:       taken:
 318 ; BUNDLES-NEXT:    ret i1 false
 319 ; BUNDLES:       not_taken:
 320 ; BUNDLES-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 321 ; BUNDLES-NEXT:    [[RVAL_2:%.*]] = icmp sgt i32* [[LOAD]], null
 322 ; BUNDLES-NEXT:    ret i1 [[RVAL_2]]
 323 ;
 324 entry:
 325   %load = load i32*, i32** %a
 326   %cmp = icmp ne i32* %load, null
 327   br i1 %control, label %taken, label %not_taken
 328 taken:
 329   tail call void @llvm.assume(i1 %cmp)
 330   %rval = icmp eq i32* %load, null
 331   ret i1 %rval
 332 not_taken:
 333   %rval.2 = icmp sgt i32* %load, null
 334   ret i1 %rval.2
 335 }
 336
 337 ; Make sure the above canonicalization does not trigger
 338 ; if the path from the load to the assume is potentially
 339 ; interrupted by an exception being thrown
 340
 341 define i1 @nonnull4(i32** %a) {
 342 ; DEFAULT-LABEL: @nonnull4(
 343 ; DEFAULT-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 344 ; DEFAULT-NEXT:    tail call void @escape(i32* [[LOAD]])
 345 ; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 346 ; DEFAULT-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 347 ; DEFAULT-NEXT:    ret i1 false
 348 ;
 349 ; BUNDLES-LABEL: @nonnull4(
 350 ; BUNDLES-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 351 ; BUNDLES-NEXT:    tail call void @escape(i32* [[LOAD]])
 352 ; BUNDLES-NEXT:    call void @llvm.assume(i1 true) [ "nonnull"(i32* [[LOAD]]) ]
 353 ; BUNDLES-NEXT:    ret i1 false
 354 ;
 355   %load = load i32*, i32** %a
 356   ;; This call may throw!
 357   tail call void @escape(i32* %load)
 358   %cmp = icmp ne i32* %load, null
 359   tail call void @llvm.assume(i1 %cmp)
 360   %rval = icmp eq i32* %load, null
 361   ret i1 %rval
 362 }
 363 define i1 @nonnull5(i32** %a) {
 364 ; CHECK-LABEL: @nonnull5(
 365 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 366 ; CHECK-NEXT:    tail call void @escape(i32* [[LOAD]])
 367 ; CHECK-NEXT:    [[CMP:%.*]] = icmp slt i32* [[LOAD]], null
 368 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP]])
 369 ; CHECK-NEXT:    ret i1 false
 370 ;
 371   %load = load i32*, i32** %a
 372   ;; This call may throw!
 373   tail call void @escape(i32* %load)
 374   %integral = ptrtoint i32* %load to i64
 375   %cmp = icmp slt i64 %integral, 0
 376   tail call void @llvm.assume(i1 %cmp) ; %load has at least highest bit set
 377   %rval = icmp eq i32* %load, null
 378   ret i1 %rval
 379 }
 380
 381 ; PR35846 - https://bugs.llvm.org/show_bug.cgi?id=35846
 382
 383 define i32 @assumption_conflicts_with_known_bits(i32 %a, i32 %b) {
 384 ; CHECK-LABEL: @assumption_conflicts_with_known_bits(
 385 ; CHECK-NEXT:    [[AND1:%.*]] = and i32 [[B:%.*]], 3
 386 ; CHECK-NEXT:    tail call void @llvm.assume(i1 false)
 387 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[AND1]], 0
 388 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP2]])
 389 ; CHECK-NEXT:    ret i32 0
 390 ;
 391   %and1 = and i32 %b, 3
 392   %B1 = lshr i32 %and1, %and1
 393   %B3 = shl nuw nsw i32 %and1, %B1
 394   %cmp = icmp eq i32 %B3, 1
 395   tail call void @llvm.assume(i1 %cmp)
 396   %cmp2 = icmp eq i32 %B1, %B3
 397   tail call void @llvm.assume(i1 %cmp2)
 398   ret i32 %and1
 399 }
 400
 401 ; PR37726 - https://bugs.llvm.org/show_bug.cgi?id=37726
 402 ; There's a loophole in eliminating a redundant assumption when
 403 ; we have conflicting assumptions. Verify that debuginfo doesn't
 404 ; get in the way of the fold.
 405
 406 define void @debug_interference(i8 %x) {
 407 ; CHECK-LABEL: @debug_interference(
 408 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i8 [[X:%.*]], 0
 409 ; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata [[META7:![0-9]+]], metadata !DIExpression()), !dbg [[DBG9:![0-9]+]]
 410 ; CHECK-NEXT:    tail call void @llvm.assume(i1 false)
 411 ; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata [[META7]], metadata !DIExpression()), !dbg [[DBG9]]
 412 ; CHECK-NEXT:    tail call void @llvm.dbg.value(metadata i32 5, metadata [[META7]], metadata !DIExpression()), !dbg [[DBG9]]
 413 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP2]])
 414 ; CHECK-NEXT:    ret void
 415 ;
 416   %cmp1 = icmp eq i8 %x, 0
 417   %cmp2 = icmp ne i8 %x, 0
 418   tail call void @llvm.assume(i1 %cmp1)
 419   tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9
 420   tail call void @llvm.assume(i1 %cmp1)
 421   tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9
 422   tail call void @llvm.assume(i1 %cmp2)
 423   tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9
 424   tail call void @llvm.assume(i1 %cmp2)
 425   ret void
 426 }
 427
 428 ; This would crash.
 429 ; Does it ever make sense to peek through a bitcast of the icmp operand?
 430
 431 define i32 @PR40940(<4 x i8> %x) {
 432 ; CHECK-LABEL: @PR40940(
 433 ; CHECK-NEXT:    [[SHUF:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> undef, <4 x i32> <i32 1, i32 1, i32 2, i32 3>
 434 ; CHECK-NEXT:    [[T2:%.*]] = bitcast <4 x i8> [[SHUF]] to i32
 435 ; CHECK-NEXT:    [[T3:%.*]] = icmp ult i32 [[T2]], 65536
 436 ; CHECK-NEXT:    call void @llvm.assume(i1 [[T3]])
 437 ; CHECK-NEXT:    ret i32 [[T2]]
 438 ;
 439   %shuf = shufflevector <4 x i8> %x, <4 x i8> undef, <4 x i32> <i32 1, i32 1, i32 2, i32 3>
 440   %t2 = bitcast <4 x i8> %shuf to i32
 441   %t3 = icmp ult i32 %t2, 65536
 442   call void @llvm.assume(i1 %t3)
 443   ret i32 %t2
 444 }
 445
 446 define i1 @nonnull3A(i32** %a, i1 %control) {
 447 ; DEFAULT-LABEL: @nonnull3A(
 448 ; DEFAULT-NEXT:  entry:
 449 ; DEFAULT-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 450 ; DEFAULT-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 451 ; DEFAULT:       taken:
 452 ; DEFAULT-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 453 ; DEFAULT-NEXT:    call void @llvm.assume(i1 [[CMP]])
 454 ; DEFAULT-NEXT:    ret i1 true
 455 ; DEFAULT:       not_taken:
 456 ; DEFAULT-NEXT:    [[RVAL_2:%.*]] = icmp sgt i32* [[LOAD]], null
 457 ; DEFAULT-NEXT:    ret i1 [[RVAL_2]]
 458 ;
 459 ; BUNDLES-LABEL: @nonnull3A(
 460 ; BUNDLES-NEXT:  entry:
 461 ; BUNDLES-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 462 ; BUNDLES:       taken:
 463 ; BUNDLES-NEXT:    ret i1 true
 464 ; BUNDLES:       not_taken:
 465 ; BUNDLES-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 466 ; BUNDLES-NEXT:    [[RVAL_2:%.*]] = icmp sgt i32* [[LOAD]], null
 467 ; BUNDLES-NEXT:    ret i1 [[RVAL_2]]
 468 ;
 469 entry:
 470   %load = load i32*, i32** %a
 471   %cmp = icmp ne i32* %load, null
 472   br i1 %control, label %taken, label %not_taken
 473 taken:
 474   call void @llvm.assume(i1 %cmp)
 475   ret i1 %cmp
 476 not_taken:
 477   call void @llvm.assume(i1 %cmp)
 478   %rval.2 = icmp sgt i32* %load, null
 479   ret i1 %rval.2
 480 }
 481
 482 define i1 @nonnull3B(i32** %a, i1 %control) {
 483 ; CHECK-LABEL: @nonnull3B(
 484 ; CHECK-NEXT:  entry:
 485 ; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 486 ; CHECK:       taken:
 487 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 488 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 489 ; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]]) [ "nonnull"(i32* [[LOAD]]), "nonnull"(i1 [[CMP]]) ]
 490 ; CHECK-NEXT:    ret i1 true
 491 ; CHECK:       not_taken:
 492 ; CHECK-NEXT:    ret i1 [[CONTROL]]
 493 ;
 494 entry:
 495   %load = load i32*, i32** %a
 496   %cmp = icmp ne i32* %load, null
 497   br i1 %control, label %taken, label %not_taken
 498 taken:
 499   call void @llvm.assume(i1 %cmp) ["nonnull"(i32* %load), "nonnull"(i1 %cmp)]
 500   ret i1 %cmp
 501 not_taken:
 502   call void @llvm.assume(i1 %cmp) ["nonnull"(i32* %load), "nonnull"(i1 %cmp)]
 503   ret i1 %control
 504 }
 505
 506 declare i1 @tmp1(i1)
 507
 508 define i1 @nonnull3C(i32** %a, i1 %control) {
 509 ; CHECK-LABEL: @nonnull3C(
 510 ; CHECK-NEXT:  entry:
 511 ; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 512 ; CHECK:       taken:
 513 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 514 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 515 ; CHECK-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])
 516 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 517 ; CHECK:       exit:
 518 ; CHECK-NEXT:    ret i1 [[CMP2]]
 519 ; CHECK:       not_taken:
 520 ; CHECK-NEXT:    ret i1 [[CONTROL]]
 521 ;
 522 entry:
 523   %load = load i32*, i32** %a
 524   %cmp = icmp ne i32* %load, null
 525   br i1 %control, label %taken, label %not_taken
 526 taken:
 527   %cmp2 = call i1 @tmp1(i1 %cmp)
 528   br label %exit
 529 exit:
 530   ; FIXME: this shouldn't be dropped because it is still dominated by the new position of %load
 531   call void @llvm.assume(i1 %cmp) ["nonnull"(i32* %load), "nonnull"(i1 %cmp)]
 532   ret i1 %cmp2
 533 not_taken:
 534   call void @llvm.assume(i1 %cmp)
 535   ret i1 %control
 536 }
 537
 538 define i1 @nonnull3D(i32** %a, i1 %control) {
 539 ; CHECK-LABEL: @nonnull3D(
 540 ; CHECK-NEXT:  entry:
 541 ; CHECK-NEXT:    br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]
 542 ; CHECK:       taken:
 543 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32*, i32** [[A:%.*]], align 8
 544 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ne i32* [[LOAD]], null
 545 ; CHECK-NEXT:    [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])
 546 ; CHECK-NEXT:    br label [[EXIT:%.*]]
 547 ; CHECK:       exit:
 548 ; CHECK-NEXT:    ret i1 [[CMP2]]
 549 ; CHECK:       not_taken:
 550 ; CHECK-NEXT:    call void @llvm.assume(i1 true) [ "ignore"(i32* undef), "ignore"(i1 undef), "nonnull"(i1 [[CONTROL]]) ]
 551 ; CHECK-NEXT:    ret i1 [[CONTROL]]
 552 ;
 553 entry:
 554   %load = load i32*, i32** %a
 555   %cmp = icmp ne i32* %load, null
 556   br i1 %control, label %taken, label %not_taken
 557 taken:
 558   %cmp2 = call i1 @tmp1(i1 %cmp)
 559   br label %exit
 560 exit:
 561   ret i1 %cmp2
 562 not_taken:
 563   call void @llvm.assume(i1 %cmp) ["nonnull"(i32* %load), "nonnull"(i1 %cmp), "nonnull"(i1 %control)]
 564   ret i1 %control
 565 }
 566
 567
 568 define void @always_true_assumption() {
 569 ; CHECK-LABEL: @always_true_assumption(
 570 ; CHECK-NEXT:    ret void
 571 ;
 572   call void @llvm.assume(i1 true)
 573   ret void
 574 }
 575
 576 ; The alloca guarantees that the low bits of %a are zero because of alignment.
 577 ; The assume says the opposite. Make sure we don't crash.
 578
 579 define i64 @PR31809() {
 580 ; CHECK-LABEL: @PR31809(
 581 ; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4
 582 ; CHECK-NEXT:    [[T1:%.*]] = ptrtoint i32* [[A]] to i64
 583 ; CHECK-NEXT:    call void @llvm.assume(i1 false)
 584 ; CHECK-NEXT:    ret i64 [[T1]]
 585 ;
 586   %a = alloca i32
 587   %t1 = ptrtoint i32* %a to i64
 588   %cond = icmp eq i64 %t1, 3
 589   call void @llvm.assume(i1 %cond)
 590   ret i64 %t1
 591 }
 592
 593 ; Similar to above: there's no way to know which assumption is truthful,
 594 ; so just don't crash.
 595
 596 define i8 @conflicting_assumptions(i8 %x){
 597 ; CHECK-LABEL: @conflicting_assumptions(
 598 ; CHECK-NEXT:    call void @llvm.assume(i1 false)
 599 ; CHECK-NEXT:    [[COND2:%.*]] = icmp eq i8 [[X:%.*]], 4
 600 ; CHECK-NEXT:    call void @llvm.assume(i1 [[COND2]])
 601 ; CHECK-NEXT:    ret i8 5
 602 ;
 603   %add = add i8 %x, 1
 604   %cond1 = icmp eq i8 %x, 3
 605   call void @llvm.assume(i1 %cond1)
 606   %cond2 = icmp eq i8 %x, 4
 607   call void @llvm.assume(i1 %cond2)
 608   ret i8 %add
 609 }
 610
 611 ; Another case of conflicting assumptions. This would crash because we'd
 612 ; try to set more known bits than existed in the known bits struct.
 613
 614 define void @PR36270(i32 %b) {
 615 ; CHECK-LABEL: @PR36270(
 616 ; CHECK-NEXT:    unreachable
 617 ;
 618   %B7 = xor i32 -1, 2147483647
 619   %and1 = and i32 %b, 3
 620   %B12 = lshr i32 %B7, %and1
 621   %C1 = icmp ult i32 %and1, %B12
 622   tail call void @llvm.assume(i1 %C1)
 623   %cmp2 = icmp eq i32 0, %B12
 624   tail call void @llvm.assume(i1 %cmp2)
 625   unreachable
 626 }
 627
 628 ; PR47416
 629
 630 define i32 @unreachable_assume(i32 %x, i32 %y) {
 631 ; CHECK-LABEL: @unreachable_assume(
 632 ; CHECK-NEXT:  entry:
 633 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1
 634 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1
 635 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]]
 636 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[OR]])
 637 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[X]], 1
 638 ; CHECK-NEXT:    br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]
 639 ; CHECK:       if:
 640 ; CHECK-NEXT:    [[A:%.*]] = and i32 [[Y]], -2
 641 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i32 [[A]], 104
 642 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP3]])
 643 ; CHECK-NEXT:    br label [[EXIT]]
 644 ; CHECK:       exit:
 645 ; CHECK-NEXT:    unreachable
 646 ;
 647 entry:
 648   %cmp0 = icmp sgt i32 %x, 1
 649   %cmp1 = icmp eq i32 %y, 1
 650   %or = or i1 %cmp0, %cmp1
 651   tail call void @llvm.assume(i1 %or)
 652   %cmp2 = icmp eq i32 %x, 1
 653   br i1 %cmp2, label %if, label %exit
 654
 655 if:
 656   %a = and i32 %y, -2
 657   %cmp3 = icmp ne i32 %a, 104
 658   tail call void @llvm.assume(i1 %cmp3)
 659   br label %exit
 660
 661 exit:
 662   %cmp4 = icmp eq i32 %x, 2
 663   tail call void @llvm.assume(i1 %cmp4)
 664   unreachable
 665 }
 666
 667 define i32 @unreachable_assume_logical(i32 %x, i32 %y) {
 668 ; CHECK-LABEL: @unreachable_assume_logical(
 669 ; CHECK-NEXT:  entry:
 670 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1
 671 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1
 672 ; CHECK-NEXT:    [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]]
 673 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[OR]])
 674 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[X]], 1
 675 ; CHECK-NEXT:    br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]
 676 ; CHECK:       if:
 677 ; CHECK-NEXT:    [[A:%.*]] = and i32 [[Y]], -2
 678 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i32 [[A]], 104
 679 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP3]])
 680 ; CHECK-NEXT:    br label [[EXIT]]
 681 ; CHECK:       exit:
 682 ; CHECK-NEXT:    unreachable
 683 ;
 684 entry:
 685   %cmp0 = icmp sgt i32 %x, 1
 686   %cmp1 = icmp eq i32 %y, 1
 687   %or = select i1 %cmp0, i1 true, i1 %cmp1
 688   tail call void @llvm.assume(i1 %or)
 689   %cmp2 = icmp eq i32 %x, 1
 690   br i1 %cmp2, label %if, label %exit
 691
 692 if:
 693   %a = and i32 %y, -2
 694   %cmp3 = icmp ne i32 %a, 104
 695   tail call void @llvm.assume(i1 %cmp3)
 696   br label %exit
 697
 698 exit:
 699   %cmp4 = icmp eq i32 %x, 2
 700   tail call void @llvm.assume(i1 %cmp4)
 701   unreachable
 702 }
 703
 704 define i32 @unreachable_assumes_and_store(i32 %x, i32 %y, i32* %p) {
 705 ; CHECK-LABEL: @unreachable_assumes_and_store(
 706 ; CHECK-NEXT:  entry:
 707 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1
 708 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1
 709 ; CHECK-NEXT:    [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]]
 710 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[OR]])
 711 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[X]], 1
 712 ; CHECK-NEXT:    br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]
 713 ; CHECK:       if:
 714 ; CHECK-NEXT:    [[A:%.*]] = and i32 [[Y]], -2
 715 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i32 [[A]], 104
 716 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP3]])
 717 ; CHECK-NEXT:    br label [[EXIT]]
 718 ; CHECK:       exit:
 719 ; CHECK-NEXT:    unreachable
 720 ;
 721 entry:
 722   %cmp0 = icmp sgt i32 %x, 1
 723   %cmp1 = icmp eq i32 %y, 1
 724   %or = or i1 %cmp0, %cmp1
 725   tail call void @llvm.assume(i1 %or)
 726   %cmp2 = icmp eq i32 %x, 1
 727   br i1 %cmp2, label %if, label %exit
 728
 729 if:
 730   %a = and i32 %y, -2
 731   %cmp3 = icmp ne i32 %a, 104
 732   tail call void @llvm.assume(i1 %cmp3)
 733   br label %exit
 734
 735 exit:
 736   %cmp4 = icmp eq i32 %x, 2
 737   tail call void @llvm.assume(i1 %cmp4)
 738   %cmp5 = icmp ugt i32 %y, 42
 739   tail call void @llvm.assume(i1 %cmp5)
 740   store i32 %x, i32* %p
 741   unreachable
 742 }
 743
 744 define i32 @unreachable_assumes_and_store_logical(i32 %x, i32 %y, i32* %p) {
 745 ; CHECK-LABEL: @unreachable_assumes_and_store_logical(
 746 ; CHECK-NEXT:  entry:
 747 ; CHECK-NEXT:    [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1
 748 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1
 749 ; CHECK-NEXT:    [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]]
 750 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[OR]])
 751 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp eq i32 [[X]], 1
 752 ; CHECK-NEXT:    br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]
 753 ; CHECK:       if:
 754 ; CHECK-NEXT:    [[A:%.*]] = and i32 [[Y]], -2
 755 ; CHECK-NEXT:    [[CMP3:%.*]] = icmp ne i32 [[A]], 104
 756 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP3]])
 757 ; CHECK-NEXT:    br label [[EXIT]]
 758 ; CHECK:       exit:
 759 ; CHECK-NEXT:    unreachable
 760 ;
 761 entry:
 762   %cmp0 = icmp sgt i32 %x, 1
 763   %cmp1 = icmp eq i32 %y, 1
 764   %or = select i1 %cmp0, i1 true, i1 %cmp1
 765   tail call void @llvm.assume(i1 %or)
 766   %cmp2 = icmp eq i32 %x, 1
 767   br i1 %cmp2, label %if, label %exit
 768
 769 if:
 770   %a = and i32 %y, -2
 771   %cmp3 = icmp ne i32 %a, 104
 772   tail call void @llvm.assume(i1 %cmp3)
 773   br label %exit
 774
 775 exit:
 776   %cmp4 = icmp eq i32 %x, 2
 777   tail call void @llvm.assume(i1 %cmp4)
 778   %cmp5 = icmp ugt i32 %y, 42
 779   tail call void @llvm.assume(i1 %cmp5)
 780   store i32 %x, i32* %p
 781   unreachable
 782 }
 783
 784 define void @canonicalize_assume(i32* %0) {
 785 ; DEFAULT-LABEL: @canonicalize_assume(
 786 ; DEFAULT-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, i32* [[TMP0:%.*]], i64 2
 787 ; DEFAULT-NEXT:    [[TMP3:%.*]] = bitcast i32* [[TMP2]] to i8*
 788 ; DEFAULT-NEXT:    call void @llvm.assume(i1 true) [ "align"(i8* [[TMP3]], i64 16) ]
 789 ; DEFAULT-NEXT:    ret void
 790 ;
 791 ; BUNDLES-LABEL: @canonicalize_assume(
 792 ; BUNDLES-NEXT:    call void @llvm.assume(i1 true) [ "align"(i32* [[TMP0:%.*]], i64 8) ]
 793 ; BUNDLES-NEXT:    ret void
 794 ;
 795   %2 = getelementptr inbounds i32, i32* %0, i64 2
 796   %3 = bitcast i32* %2 to i8*
 797   call void @llvm.assume(i1 true) [ "align"(i8* %3, i64 16) ]
 798   ret void
 799 }
 800
 801 declare void @llvm.dbg.value(metadata, metadata, metadata)
 802
 803 !llvm.dbg.cu = !{!0}
 804 !llvm.module.flags = !{!5, !6, !7, !8}
 805
 806 !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "Me", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: null, retainedTypes: null, imports: null)
 807 !1 = !DILocalVariable(name: "", arg: 1, scope: !2, file: null, line: 1, type: null)
 808 !2 = distinct !DISubprogram(name: "debug", linkageName: "debug", scope: null, file: null, line: 0, type: null, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: true, unit: !0)
 809 !3 = !DIFile(filename: "consecutive-fences.ll", directory: "")
 810 !5 = !{i32 2, !"Dwarf Version", i32 4}
 811 !6 = !{i32 2, !"Debug Info Version", i32 3}
 812 !7 = !{i32 1, !"wchar_size", i32 4}
 813 !8 = !{i32 7, !"PIC Level", i32 2}
 814 !9 = !DILocation(line: 0, column: 0, scope: !2)
 815
 816
 817 attributes #0 = { nounwind uwtable }
 818 attributes #1 = { nounwind }
 819