1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -passes=instcombine -S -instcombine-infinite-loop-threshold=2 | FileCheck --check-prefixes=CHECK,DEFAULT %s 3; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -S -instcombine-infinite-loop-threshold=2 | FileCheck --check-prefixes=CHECK,BUNDLES %s 4 5target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 6target triple = "x86_64-unknown-linux-gnu" 7 8declare void @llvm.assume(i1) #1 9 10; Check that the alignment has been upgraded and that the assume has not 11; been removed: 12 13define i32 @foo1(ptr %a) #0 { 14; DEFAULT-LABEL: @foo1( 15; DEFAULT-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 32 16; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[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, ptr [[A:%.*]], align 32 24; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i64 32) ] 25; BUNDLES-NEXT: ret i32 [[T0]] 26; 27 %t0 = load i32, ptr %a, align 4 28 %ptrint = ptrtoint ptr %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 37define i32 @foo2(ptr %a) #0 { 38; DEFAULT-LABEL: @foo2( 39; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[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, ptr [[A]], align 32 44; DEFAULT-NEXT: ret i32 [[T0]] 45; 46; BUNDLES-LABEL: @foo2( 47; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A:%.*]], i64 32) ] 48; BUNDLES-NEXT: [[T0:%.*]] = load i32, ptr [[A]], align 32 49; BUNDLES-NEXT: ret i32 [[T0]] 50; 51 %ptrint = ptrtoint ptr %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, ptr %a, align 4 56 ret i32 %t0 57} 58 59define 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 70define 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 83define 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 96define 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 110define 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 124define 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 138define 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 152define 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; 162entry: 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 182define 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; 193entry: 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 203define 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 215define 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 230define 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 241declare void @escape(ptr %a) 242 243; Canonicalize a nonnull assumption on a load into metadata form. 244 245define i32 @bundle1(ptr %P) { 246; CHECK-LABEL: @bundle1( 247; CHECK-NEXT: tail call void @llvm.assume(i1 true) [ "nonnull"(ptr [[P:%.*]]) ] 248; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[P]], align 4 249; CHECK-NEXT: ret i32 [[LOAD]] 250; 251 tail call void @llvm.assume(i1 true) ["nonnull"(ptr %P)] 252 %load = load i32, ptr %P 253 ret i32 %load 254} 255 256define i32 @bundle2(ptr %P) { 257; CHECK-LABEL: @bundle2( 258; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[P:%.*]], align 4 259; CHECK-NEXT: ret i32 [[LOAD]] 260; 261 tail call void @llvm.assume(i1 true) ["ignore"(ptr undef)] 262 %load = load i32, ptr %P 263 ret i32 %load 264} 265 266define i1 @nonnull1(ptr %a) { 267; CHECK-LABEL: @nonnull1( 268; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8, !nonnull !6 269; CHECK-NEXT: tail call void @escape(ptr nonnull [[LOAD]]) 270; CHECK-NEXT: ret i1 false 271; 272 %load = load ptr, ptr %a 273 %cmp = icmp ne ptr %load, null 274 tail call void @llvm.assume(i1 %cmp) 275 tail call void @escape(ptr %load) 276 %rval = icmp eq ptr %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 283define i1 @nonnull2(ptr %a) { 284; CHECK-LABEL: @nonnull2( 285; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[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, ptr %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 300define i1 @nonnull3(ptr %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 ptr, ptr [[A:%.*]], align 8 305; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[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 ptr [[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 ptr, ptr [[A:%.*]], align 8 321; BUNDLES-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null 322; BUNDLES-NEXT: ret i1 [[RVAL_2]] 323; 324entry: 325 %load = load ptr, ptr %a 326 %cmp = icmp ne ptr %load, null 327 br i1 %control, label %taken, label %not_taken 328taken: 329 tail call void @llvm.assume(i1 %cmp) 330 %rval = icmp eq ptr %load, null 331 ret i1 %rval 332not_taken: 333 %rval.2 = icmp sgt ptr %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 341define i1 @nonnull4(ptr %a) { 342; DEFAULT-LABEL: @nonnull4( 343; DEFAULT-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8 344; DEFAULT-NEXT: tail call void @escape(ptr [[LOAD]]) 345; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[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 ptr, ptr [[A:%.*]], align 8 351; BUNDLES-NEXT: tail call void @escape(ptr [[LOAD]]) 352; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ] 353; BUNDLES-NEXT: ret i1 false 354; 355 %load = load ptr, ptr %a 356 ;; This call may throw! 357 tail call void @escape(ptr %load) 358 %cmp = icmp ne ptr %load, null 359 tail call void @llvm.assume(i1 %cmp) 360 %rval = icmp eq ptr %load, null 361 ret i1 %rval 362} 363define i1 @nonnull5(ptr %a) { 364; CHECK-LABEL: @nonnull5( 365; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8 366; CHECK-NEXT: tail call void @escape(ptr [[LOAD]]) 367; CHECK-NEXT: [[CMP:%.*]] = icmp slt ptr [[LOAD]], null 368; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]]) 369; CHECK-NEXT: ret i1 false 370; 371 %load = load ptr, ptr %a 372 ;; This call may throw! 373 tail call void @escape(ptr %load) 374 %integral = ptrtoint ptr %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 ptr %load, null 378 ret i1 %rval 379} 380 381; PR35846 - https://bugs.llvm.org/show_bug.cgi?id=35846 382 383define 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 406define 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 431define 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 446define i1 @nonnull3A(ptr %a, i1 %control) { 447; DEFAULT-LABEL: @nonnull3A( 448; DEFAULT-NEXT: entry: 449; DEFAULT-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8 450; DEFAULT-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]] 451; DEFAULT: taken: 452; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[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 ptr [[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 ptr, ptr [[A:%.*]], align 8 466; BUNDLES-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null 467; BUNDLES-NEXT: ret i1 [[RVAL_2]] 468; 469entry: 470 %load = load ptr, ptr %a 471 %cmp = icmp ne ptr %load, null 472 br i1 %control, label %taken, label %not_taken 473taken: 474 call void @llvm.assume(i1 %cmp) 475 ret i1 %cmp 476not_taken: 477 call void @llvm.assume(i1 %cmp) 478 %rval.2 = icmp sgt ptr %load, null 479 ret i1 %rval.2 480} 481 482define i1 @nonnull3B(ptr %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 ptr, ptr [[A:%.*]], align 8 488; CHECK-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null 489; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) [ "nonnull"(ptr [[LOAD]]) ] 490; CHECK-NEXT: ret i1 true 491; CHECK: not_taken: 492; CHECK-NEXT: ret i1 [[CONTROL]] 493; 494entry: 495 %load = load ptr, ptr %a 496 %cmp = icmp ne ptr %load, null 497 br i1 %control, label %taken, label %not_taken 498taken: 499 call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)] 500 ret i1 %cmp 501not_taken: 502 call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)] 503 ret i1 %control 504} 505 506declare i1 @tmp1(i1) 507 508define i1 @nonnull3C(ptr %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 ptr, ptr [[A:%.*]], align 8 514; CHECK-NEXT: [[CMP:%.*]] = icmp ne ptr [[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; 522entry: 523 %load = load ptr, ptr %a 524 %cmp = icmp ne ptr %load, null 525 br i1 %control, label %taken, label %not_taken 526taken: 527 %cmp2 = call i1 @tmp1(i1 %cmp) 528 br label %exit 529exit: 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"(ptr %load)] 532 ret i1 %cmp2 533not_taken: 534 call void @llvm.assume(i1 %cmp) 535 ret i1 %control 536} 537 538define i1 @nonnull3D(ptr %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 ptr, ptr [[A:%.*]], align 8 544; CHECK-NEXT: [[CMP:%.*]] = icmp ne ptr [[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: ret i1 [[CONTROL]] 551; 552entry: 553 %load = load ptr, ptr %a 554 %cmp = icmp ne ptr %load, null 555 br i1 %control, label %taken, label %not_taken 556taken: 557 %cmp2 = call i1 @tmp1(i1 %cmp) 558 br label %exit 559exit: 560 ret i1 %cmp2 561not_taken: 562 call void @llvm.assume(i1 %cmp) ["nonnull"(ptr %load)] 563 ret i1 %control 564} 565 566 567define void @always_true_assumption() { 568; CHECK-LABEL: @always_true_assumption( 569; CHECK-NEXT: ret void 570; 571 call void @llvm.assume(i1 true) 572 ret void 573} 574 575; The alloca guarantees that the low bits of %a are zero because of alignment. 576; The assume says the opposite. Make sure we don't crash. 577 578define i64 @PR31809() { 579; CHECK-LABEL: @PR31809( 580; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4 581; CHECK-NEXT: [[T1:%.*]] = ptrtoint ptr [[A]] to i64 582; CHECK-NEXT: call void @llvm.assume(i1 false) 583; CHECK-NEXT: ret i64 [[T1]] 584; 585 %a = alloca i32 586 %t1 = ptrtoint ptr %a to i64 587 %cond = icmp eq i64 %t1, 3 588 call void @llvm.assume(i1 %cond) 589 ret i64 %t1 590} 591 592; Similar to above: there's no way to know which assumption is truthful, 593; so just don't crash. 594 595define i8 @conflicting_assumptions(i8 %x){ 596; CHECK-LABEL: @conflicting_assumptions( 597; CHECK-NEXT: call void @llvm.assume(i1 false) 598; CHECK-NEXT: [[COND2:%.*]] = icmp eq i8 [[X:%.*]], 4 599; CHECK-NEXT: call void @llvm.assume(i1 [[COND2]]) 600; CHECK-NEXT: ret i8 5 601; 602 %add = add i8 %x, 1 603 %cond1 = icmp eq i8 %x, 3 604 call void @llvm.assume(i1 %cond1) 605 %cond2 = icmp eq i8 %x, 4 606 call void @llvm.assume(i1 %cond2) 607 ret i8 %add 608} 609 610; Another case of conflicting assumptions. This would crash because we'd 611; try to set more known bits than existed in the known bits struct. 612 613define void @PR36270(i32 %b) { 614; CHECK-LABEL: @PR36270( 615; CHECK-NEXT: unreachable 616; 617 %B7 = xor i32 -1, 2147483647 618 %and1 = and i32 %b, 3 619 %B12 = lshr i32 %B7, %and1 620 %C1 = icmp ult i32 %and1, %B12 621 tail call void @llvm.assume(i1 %C1) 622 %cmp2 = icmp eq i32 0, %B12 623 tail call void @llvm.assume(i1 %cmp2) 624 unreachable 625} 626 627; PR47416 628 629define i32 @unreachable_assume(i32 %x, i32 %y) { 630; CHECK-LABEL: @unreachable_assume( 631; CHECK-NEXT: entry: 632; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1 633; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1 634; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]] 635; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]]) 636; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1 637; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]] 638; CHECK: if: 639; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2 640; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104 641; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]]) 642; CHECK-NEXT: br label [[EXIT]] 643; CHECK: exit: 644; CHECK-NEXT: unreachable 645; 646entry: 647 %cmp0 = icmp sgt i32 %x, 1 648 %cmp1 = icmp eq i32 %y, 1 649 %or = or i1 %cmp0, %cmp1 650 tail call void @llvm.assume(i1 %or) 651 %cmp2 = icmp eq i32 %x, 1 652 br i1 %cmp2, label %if, label %exit 653 654if: 655 %a = and i32 %y, -2 656 %cmp3 = icmp ne i32 %a, 104 657 tail call void @llvm.assume(i1 %cmp3) 658 br label %exit 659 660exit: 661 %cmp4 = icmp eq i32 %x, 2 662 tail call void @llvm.assume(i1 %cmp4) 663 unreachable 664} 665 666define i32 @unreachable_assume_logical(i32 %x, i32 %y) { 667; CHECK-LABEL: @unreachable_assume_logical( 668; CHECK-NEXT: entry: 669; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1 670; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1 671; CHECK-NEXT: [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]] 672; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]]) 673; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1 674; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]] 675; CHECK: if: 676; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2 677; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104 678; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]]) 679; CHECK-NEXT: br label [[EXIT]] 680; CHECK: exit: 681; CHECK-NEXT: unreachable 682; 683entry: 684 %cmp0 = icmp sgt i32 %x, 1 685 %cmp1 = icmp eq i32 %y, 1 686 %or = select i1 %cmp0, i1 true, i1 %cmp1 687 tail call void @llvm.assume(i1 %or) 688 %cmp2 = icmp eq i32 %x, 1 689 br i1 %cmp2, label %if, label %exit 690 691if: 692 %a = and i32 %y, -2 693 %cmp3 = icmp ne i32 %a, 104 694 tail call void @llvm.assume(i1 %cmp3) 695 br label %exit 696 697exit: 698 %cmp4 = icmp eq i32 %x, 2 699 tail call void @llvm.assume(i1 %cmp4) 700 unreachable 701} 702 703define i32 @unreachable_assumes_and_store(i32 %x, i32 %y, ptr %p) { 704; CHECK-LABEL: @unreachable_assumes_and_store( 705; CHECK-NEXT: entry: 706; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1 707; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1 708; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]] 709; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]]) 710; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1 711; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]] 712; CHECK: if: 713; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2 714; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104 715; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]]) 716; CHECK-NEXT: br label [[EXIT]] 717; CHECK: exit: 718; CHECK-NEXT: unreachable 719; 720entry: 721 %cmp0 = icmp sgt i32 %x, 1 722 %cmp1 = icmp eq i32 %y, 1 723 %or = or i1 %cmp0, %cmp1 724 tail call void @llvm.assume(i1 %or) 725 %cmp2 = icmp eq i32 %x, 1 726 br i1 %cmp2, label %if, label %exit 727 728if: 729 %a = and i32 %y, -2 730 %cmp3 = icmp ne i32 %a, 104 731 tail call void @llvm.assume(i1 %cmp3) 732 br label %exit 733 734exit: 735 %cmp4 = icmp eq i32 %x, 2 736 tail call void @llvm.assume(i1 %cmp4) 737 %cmp5 = icmp ugt i32 %y, 42 738 tail call void @llvm.assume(i1 %cmp5) 739 store i32 %x, ptr %p 740 unreachable 741} 742 743define i32 @unreachable_assumes_and_store_logical(i32 %x, i32 %y, ptr %p) { 744; CHECK-LABEL: @unreachable_assumes_and_store_logical( 745; CHECK-NEXT: entry: 746; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1 747; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1 748; CHECK-NEXT: [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]] 749; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]]) 750; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1 751; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]] 752; CHECK: if: 753; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2 754; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104 755; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]]) 756; CHECK-NEXT: br label [[EXIT]] 757; CHECK: exit: 758; CHECK-NEXT: unreachable 759; 760entry: 761 %cmp0 = icmp sgt i32 %x, 1 762 %cmp1 = icmp eq i32 %y, 1 763 %or = select i1 %cmp0, i1 true, i1 %cmp1 764 tail call void @llvm.assume(i1 %or) 765 %cmp2 = icmp eq i32 %x, 1 766 br i1 %cmp2, label %if, label %exit 767 768if: 769 %a = and i32 %y, -2 770 %cmp3 = icmp ne i32 %a, 104 771 tail call void @llvm.assume(i1 %cmp3) 772 br label %exit 773 774exit: 775 %cmp4 = icmp eq i32 %x, 2 776 tail call void @llvm.assume(i1 %cmp4) 777 %cmp5 = icmp ugt i32 %y, 42 778 tail call void @llvm.assume(i1 %cmp5) 779 store i32 %x, ptr %p 780 unreachable 781} 782 783define void @canonicalize_assume(ptr %0) { 784; DEFAULT-LABEL: @canonicalize_assume( 785; DEFAULT-NEXT: [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP0:%.*]], i64 2 786; DEFAULT-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[TMP2]], i64 16) ] 787; DEFAULT-NEXT: ret void 788; 789; BUNDLES-LABEL: @canonicalize_assume( 790; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[TMP0:%.*]], i64 8) ] 791; BUNDLES-NEXT: ret void 792; 793 %2 = getelementptr inbounds i32, ptr %0, i64 2 794 call void @llvm.assume(i1 true) [ "align"(ptr %2, i64 16) ] 795 ret void 796} 797 798define void @assume_makes_and_known_assume_on_arg(ptr %p, i32 %x) { 799; CHECK-LABEL: @assume_makes_and_known_assume_on_arg( 800; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 1 801; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0 802; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) 803; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4 804; CHECK-NEXT: ret void 805; 806 %and = and i32 %x, 1 807 %cmp = icmp eq i32 %and, 0 808 call void @llvm.assume(i1 %cmp) 809 %and2 = and i32 %x, 1 810 store i32 %and2, ptr %p 811 ret void 812} 813 814define void @assume_makes_and_known_assume_on_mul(ptr %p, i32 %a, i32 %b) { 815; CHECK-LABEL: @assume_makes_and_known_assume_on_mul( 816; CHECK-NEXT: [[X:%.*]] = mul i32 [[A:%.*]], [[B:%.*]] 817; CHECK-NEXT: [[AND:%.*]] = and i32 [[X]], 1 818; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0 819; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) 820; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4 821; CHECK-NEXT: ret void 822; 823 %x = mul i32 %a, %b 824 %and = and i32 %x, 1 825 %cmp = icmp eq i32 %and, 0 826 call void @llvm.assume(i1 %cmp) 827 %and2 = and i32 %x, 1 828 store i32 %and2, ptr %p 829 ret void 830} 831 832define void @assume_makes_and_known_assume_on_bitwise(ptr %p, i32 %a, i32 %b) { 833; CHECK-LABEL: @assume_makes_and_known_assume_on_bitwise( 834; CHECK-NEXT: [[X:%.*]] = or i32 [[A:%.*]], [[B:%.*]] 835; CHECK-NEXT: [[AND:%.*]] = and i32 [[X]], 1 836; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0 837; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) 838; CHECK-NEXT: [[AND2:%.*]] = and i32 [[X]], 1 839; CHECK-NEXT: store i32 [[AND2]], ptr [[P:%.*]], align 4 840; CHECK-NEXT: ret void 841; 842 %x = or i32 %a, %b 843 %and = and i32 %x, 1 844 %cmp = icmp eq i32 %and, 0 845 call void @llvm.assume(i1 %cmp) 846 %and2 = and i32 %x, 1 847 store i32 %and2, ptr %p 848 ret void 849} 850 851declare void @llvm.dbg.value(metadata, metadata, metadata) 852 853!llvm.dbg.cu = !{!0} 854!llvm.module.flags = !{!5, !6, !7, !8} 855 856!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "Me", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: null, retainedTypes: null, imports: null) 857!1 = !DILocalVariable(name: "", arg: 1, scope: !2, file: null, line: 1, type: null) 858!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) 859!3 = !DIFile(filename: "consecutive-fences.ll", directory: "") 860!5 = !{i32 2, !"Dwarf Version", i32 4} 861!6 = !{i32 2, !"Debug Info Version", i32 3} 862!7 = !{i32 1, !"wchar_size", i32 4} 863!8 = !{i32 7, !"PIC Level", i32 2} 864!9 = !DILocation(line: 0, column: 0, scope: !2) 865 866 867attributes #0 = { nounwind uwtable } 868attributes #1 = { nounwind } 869 870