1079 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py2; RUN: opt < %s -passes=instcombine -S | FileCheck --check-prefixes=CHECK,DEFAULT %s3; RUN: opt < %s -passes=instcombine --enable-knowledge-retention -S | FileCheck --check-prefixes=CHECK,BUNDLES %s4 5 6target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"7target triple = "x86_64-unknown-linux-gnu"8 9declare void @llvm.assume(i1) #110 11; Check that the assume has not been removed:12 13define i32 @align_to_bundle(ptr %a) #0 {14; DEFAULT-LABEL: @align_to_bundle(15; DEFAULT-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 416; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i6417; DEFAULT-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 3118; DEFAULT-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 019; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])20; DEFAULT-NEXT: ret i32 [[T0]]21;22; BUNDLES-LABEL: @align_to_bundle(23; BUNDLES-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 424; 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 428 %ptrint = ptrtoint ptr %a to i6429 %maskedptr = and i64 %ptrint, 3130 %maskcond = icmp eq i64 %maskedptr, 031 tail call void @llvm.assume(i1 %maskcond)32 ret i32 %t033}34 35define i32 @align_to_bundle_ptrtoaddr(ptr %a) #0 {36; DEFAULT-LABEL: @align_to_bundle_ptrtoaddr(37; DEFAULT-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 438; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoaddr ptr [[A]] to i6439; DEFAULT-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 3140; DEFAULT-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 041; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])42; DEFAULT-NEXT: ret i32 [[T0]]43;44; BUNDLES-LABEL: @align_to_bundle_ptrtoaddr(45; BUNDLES-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 446; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i64 32) ]47; BUNDLES-NEXT: ret i32 [[T0]]48;49 %t0 = load i32, ptr %a, align 450 %ptrint = ptrtoaddr ptr %a to i6451 %maskedptr = and i64 %ptrint, 3152 %maskcond = icmp eq i64 %maskedptr, 053 tail call void @llvm.assume(i1 %maskcond)54 ret i32 %t055}56 57define i32 @align_assume_trunc_cond(ptr %a) #0 {58; DEFAULT-LABEL: @align_assume_trunc_cond(59; DEFAULT-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 460; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i6461; DEFAULT-NEXT: [[TRUNC:%.*]] = trunc i64 [[PTRINT]] to i162; DEFAULT-NEXT: [[MASKCOND:%.*]] = xor i1 [[TRUNC]], true63; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])64; DEFAULT-NEXT: ret i32 [[T0]]65;66; BUNDLES-LABEL: @align_assume_trunc_cond(67; BUNDLES-NEXT: [[T0:%.*]] = load i32, ptr [[A:%.*]], align 468; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i64 2) ]69; BUNDLES-NEXT: ret i32 [[T0]]70;71 %t0 = load i32, ptr %a, align 472 %ptrint = ptrtoint ptr %a to i6473 %trunc = trunc i64 %ptrint to i174 %maskcond = xor i1 %trunc, true75 tail call void @llvm.assume(i1 %maskcond)76 ret i32 %t077}78 79; Same check as in @foo1, but make sure it works if the assume is first too.80 81define i32 @foo2(ptr %a) #0 {82; DEFAULT-LABEL: @foo2(83; DEFAULT-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A:%.*]] to i6484; DEFAULT-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 3185; DEFAULT-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 086; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])87; DEFAULT-NEXT: [[T0:%.*]] = load i32, ptr [[A]], align 488; DEFAULT-NEXT: ret i32 [[T0]]89;90; BUNDLES-LABEL: @foo2(91; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A:%.*]], i64 32) ]92; BUNDLES-NEXT: [[T0:%.*]] = load i32, ptr [[A]], align 493; BUNDLES-NEXT: ret i32 [[T0]]94;95 %ptrint = ptrtoint ptr %a to i6496 %maskedptr = and i64 %ptrint, 3197 %maskcond = icmp eq i64 %maskedptr, 098 tail call void @llvm.assume(i1 %maskcond)99 %t0 = load i32, ptr %a, align 4100 ret i32 %t0101}102 103define i32 @simple(i32 %a) #1 {104; CHECK-LABEL: @simple(105; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], 4106; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])107; CHECK-NEXT: ret i32 [[A]]108;109 %cmp = icmp eq i32 %a, 4110 tail call void @llvm.assume(i1 %cmp)111 ret i32 %a112}113 114define i32 @can1(i1 %a, i1 %b, i1 %c) {115; CHECK-LABEL: @can1(116; CHECK-NEXT: call void @llvm.assume(i1 [[A:%.*]])117; CHECK-NEXT: call void @llvm.assume(i1 [[B:%.*]])118; CHECK-NEXT: call void @llvm.assume(i1 [[C:%.*]])119; CHECK-NEXT: ret i32 5120;121 %and1 = and i1 %a, %b122 %and = and i1 %and1, %c123 tail call void @llvm.assume(i1 %and)124 ret i32 5125}126 127define i32 @can1_logical(i1 %a, i1 %b, i1 %c) {128; CHECK-LABEL: @can1_logical(129; CHECK-NEXT: call void @llvm.assume(i1 [[A:%.*]])130; CHECK-NEXT: call void @llvm.assume(i1 [[B:%.*]])131; CHECK-NEXT: call void @llvm.assume(i1 [[C:%.*]])132; CHECK-NEXT: ret i32 5133;134 %and1 = select i1 %a, i1 %b, i1 false135 %and = select i1 %and1, i1 %c, i1 false136 tail call void @llvm.assume(i1 %and)137 ret i32 5138}139 140define i32 @can2(i1 %a, i1 %b, i1 %c) {141; CHECK-LABEL: @can2(142; CHECK-NEXT: [[TMP1:%.*]] = xor i1 [[A:%.*]], true143; CHECK-NEXT: call void @llvm.assume(i1 [[TMP1]])144; CHECK-NEXT: [[TMP2:%.*]] = xor i1 [[B:%.*]], true145; CHECK-NEXT: call void @llvm.assume(i1 [[TMP2]])146; CHECK-NEXT: ret i32 5147;148 %v = or i1 %a, %b149 %w = xor i1 %v, 1150 tail call void @llvm.assume(i1 %w)151 ret i32 5152}153 154define i32 @can2_logical(i1 %a, i1 %b, i1 %c) {155; CHECK-LABEL: @can2_logical(156; CHECK-NEXT: [[TMP1:%.*]] = xor i1 [[A:%.*]], true157; CHECK-NEXT: call void @llvm.assume(i1 [[TMP1]])158; CHECK-NEXT: [[TMP2:%.*]] = xor i1 [[B:%.*]], true159; CHECK-NEXT: call void @llvm.assume(i1 [[TMP2]])160; CHECK-NEXT: ret i32 5161;162 %v = select i1 %a, i1 true, i1 %b163 %w = xor i1 %v, 1164 tail call void @llvm.assume(i1 %w)165 ret i32 5166}167 168define i32 @bar1(i32 %a) #0 {169; CHECK-LABEL: @bar1(170; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 7171; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 1172; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])173; CHECK-NEXT: ret i32 1174;175 %and1 = and i32 %a, 3176 %and = and i32 %a, 7177 %cmp = icmp eq i32 %and, 1178 tail call void @llvm.assume(i1 %cmp)179 ret i32 %and1180}181 182define i32 @bar2(i32 %a) #0 {183; CHECK-LABEL: @bar2(184; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 7185; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 1186; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])187; CHECK-NEXT: ret i32 1188;189 %and = and i32 %a, 7190 %cmp = icmp eq i32 %and, 1191 tail call void @llvm.assume(i1 %cmp)192 %and1 = and i32 %a, 3193 ret i32 %and1194}195 196define i32 @bar3(i32 %a, i1 %x, i1 %y) #0 {197; CHECK-LABEL: @bar3(198; CHECK-NEXT: entry:199; CHECK-NEXT: tail call void @llvm.assume(i1 [[X:%.*]])200; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 7201; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 1202; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])203; CHECK-NEXT: tail call void @llvm.assume(i1 [[Y:%.*]])204; CHECK-NEXT: ret i32 1205;206entry:207 %and1 = and i32 %a, 3208 209; Don't be fooled by other assumes around.210 211 tail call void @llvm.assume(i1 %x)212 213 %and = and i32 %a, 7214 %cmp = icmp eq i32 %and, 1215 tail call void @llvm.assume(i1 %cmp)216 217 tail call void @llvm.assume(i1 %y)218 219 ret i32 %and1220}221 222; If we allow recursive known bits queries based on223; assumptions, we could do better here:224; a == b and a & 7 == 1, so b & 7 == 1, so b & 3 == 1, so return 1.225 226define i32 @known_bits_recursion_via_assumes(i32 %a, i32 %b) {227; CHECK-LABEL: @known_bits_recursion_via_assumes(228; CHECK-NEXT: entry:229; CHECK-NEXT: [[AND1:%.*]] = and i32 [[B:%.*]], 3230; CHECK-NEXT: [[AND:%.*]] = and i32 [[A:%.*]], 7231; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 1232; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])233; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[A]], [[B]]234; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP2]])235; CHECK-NEXT: ret i32 [[AND1]]236;237entry:238 %and1 = and i32 %b, 3239 %and = and i32 %a, 7240 %cmp = icmp eq i32 %and, 1241 tail call void @llvm.assume(i1 %cmp)242 %cmp2 = icmp eq i32 %a, %b243 tail call void @llvm.assume(i1 %cmp2)244 ret i32 %and1245}246 247define i32 @icmp1(i32 %a) #0 {248; CHECK-LABEL: @icmp1(249; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5250; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])251; CHECK-NEXT: [[CONV:%.*]] = zext i1 [[CMP]] to i32252; CHECK-NEXT: ret i32 [[CONV]]253;254 %cmp = icmp sgt i32 %a, 5255 tail call void @llvm.assume(i1 %cmp)256 %conv = zext i1 %cmp to i32257 ret i32 %conv258}259 260define i32 @icmp2(i32 %a) #0 {261; CHECK-LABEL: @icmp2(262; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[A:%.*]], 5263; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])264; CHECK-NEXT: ret i32 0265;266 %cmp = icmp sgt i32 %a, 5267 tail call void @llvm.assume(i1 %cmp)268 %t0 = zext i1 %cmp to i32269 %lnot.ext = xor i32 %t0, 1270 ret i32 %lnot.ext271}272 273; If the 'not' of a condition is known true, then the condition must be false.274 275define i1 @assume_not(i1 %cond) {276; CHECK-LABEL: @assume_not(277; CHECK-NEXT: [[NOTCOND:%.*]] = xor i1 [[COND:%.*]], true278; CHECK-NEXT: call void @llvm.assume(i1 [[NOTCOND]])279; CHECK-NEXT: ret i1 [[COND]]280;281 %notcond = xor i1 %cond, true282 call void @llvm.assume(i1 %notcond)283 ret i1 %cond284}285 286declare void @escape(ptr %a)287 288; Canonicalize a nonnull assumption on a load into metadata form.289 290define i32 @bundle1(ptr %P) {291; CHECK-LABEL: @bundle1(292; CHECK-NEXT: tail call void @llvm.assume(i1 true) [ "nonnull"(ptr [[P:%.*]]) ]293; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[P]], align 4294; CHECK-NEXT: ret i32 [[LOAD]]295;296 tail call void @llvm.assume(i1 true) ["nonnull"(ptr %P)]297 %load = load i32, ptr %P298 ret i32 %load299}300 301define i32 @bundle2(ptr %P) {302; CHECK-LABEL: @bundle2(303; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[P:%.*]], align 4304; CHECK-NEXT: ret i32 [[LOAD]]305;306 tail call void @llvm.assume(i1 true) ["ignore"(ptr undef)]307 %load = load i32, ptr %P308 ret i32 %load309}310 311define i1 @nonnull1(ptr %a) {312; CHECK-LABEL: @nonnull1(313; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8, !nonnull [[META6:![0-9]+]], !noundef [[META6]]314; CHECK-NEXT: tail call void @escape(ptr nonnull [[LOAD]])315; CHECK-NEXT: ret i1 false316;317 %load = load ptr, ptr %a318 %cmp = icmp ne ptr %load, null319 tail call void @llvm.assume(i1 %cmp)320 tail call void @escape(ptr %load)321 %rval = icmp eq ptr %load, null322 ret i1 %rval323}324 325; Make sure the above canonicalization applies only326; to pointer types. Doing otherwise would be illegal.327 328define i1 @nonnull2(ptr %a) {329; CHECK-LABEL: @nonnull2(330; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[A:%.*]], align 4331; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[LOAD]], 0332; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])333; CHECK-NEXT: ret i1 false334;335 %load = load i32, ptr %a336 %cmp = icmp ne i32 %load, 0337 tail call void @llvm.assume(i1 %cmp)338 %rval = icmp eq i32 %load, 0339 ret i1 %rval340}341 342; Make sure the above canonicalization does not trigger343; if the assume is control dependent on something else344 345define i1 @nonnull3(ptr %a, i1 %control) {346; FIXME: in the BUNDLES version we could duplicate the load and keep the assume nonnull.347; DEFAULT-LABEL: @nonnull3(348; DEFAULT-NEXT: entry:349; DEFAULT-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8350; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null351; DEFAULT-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]352; DEFAULT: taken:353; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[CMP]])354; DEFAULT-NEXT: ret i1 false355; DEFAULT: not_taken:356; DEFAULT-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null357; DEFAULT-NEXT: ret i1 [[RVAL_2]]358;359; BUNDLES-LABEL: @nonnull3(360; BUNDLES-NEXT: entry:361; BUNDLES-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]362; BUNDLES: taken:363; BUNDLES-NEXT: ret i1 false364; BUNDLES: not_taken:365; BUNDLES-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8366; BUNDLES-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null367; BUNDLES-NEXT: ret i1 [[RVAL_2]]368;369entry:370 %load = load ptr, ptr %a371 %cmp = icmp ne ptr %load, null372 br i1 %control, label %taken, label %not_taken373taken:374 tail call void @llvm.assume(i1 %cmp)375 %rval = icmp eq ptr %load, null376 ret i1 %rval377not_taken:378 %rval.2 = icmp sgt ptr %load, null379 ret i1 %rval.2380}381 382; Make sure the above canonicalization does not trigger383; if the path from the load to the assume is potentially384; interrupted by an exception being thrown385 386define i1 @nonnull4(ptr %a) {387; DEFAULT-LABEL: @nonnull4(388; DEFAULT-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8389; DEFAULT-NEXT: tail call void @escape(ptr [[LOAD]])390; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null391; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[CMP]])392; DEFAULT-NEXT: ret i1 false393;394; BUNDLES-LABEL: @nonnull4(395; BUNDLES-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8396; BUNDLES-NEXT: tail call void @escape(ptr [[LOAD]])397; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]398; BUNDLES-NEXT: ret i1 false399;400 %load = load ptr, ptr %a401 ;; This call may throw!402 tail call void @escape(ptr %load)403 %cmp = icmp ne ptr %load, null404 tail call void @llvm.assume(i1 %cmp)405 %rval = icmp eq ptr %load, null406 ret i1 %rval407}408define i1 @nonnull5(ptr %a) {409; CHECK-LABEL: @nonnull5(410; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8411; CHECK-NEXT: tail call void @escape(ptr [[LOAD]])412; CHECK-NEXT: [[CMP:%.*]] = icmp slt ptr [[LOAD]], null413; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP]])414; CHECK-NEXT: ret i1 false415;416 %load = load ptr, ptr %a417 ;; This call may throw!418 tail call void @escape(ptr %load)419 %integral = ptrtoint ptr %load to i64420 %cmp = icmp slt i64 %integral, 0421 tail call void @llvm.assume(i1 %cmp) ; %load has at least highest bit set422 %rval = icmp eq ptr %load, null423 ret i1 %rval424}425 426; PR35846 - https://bugs.llvm.org/show_bug.cgi?id=35846427 428define i32 @assumption_conflicts_with_known_bits(i32 %a, i32 %b) {429; CHECK-LABEL: @assumption_conflicts_with_known_bits(430; CHECK-NEXT: store i1 true, ptr poison, align 1431; CHECK-NEXT: ret i32 poison432;433 %and1 = and i32 %b, 3434 %B1 = lshr i32 %and1, %and1435 %B3 = shl nuw nsw i32 %and1, %B1436 %cmp = icmp eq i32 %B3, 1437 tail call void @llvm.assume(i1 %cmp)438 %cmp2 = icmp eq i32 %B1, %B3439 tail call void @llvm.assume(i1 %cmp2)440 ret i32 %and1441}442 443; PR37726 - https://bugs.llvm.org/show_bug.cgi?id=37726444; There's a loophole in eliminating a redundant assumption when445; we have conflicting assumptions. Verify that debuginfo doesn't446; get in the way of the fold.447 448define void @debug_interference(i8 %x) {449; CHECK-LABEL: @debug_interference(450; CHECK-NEXT: #dbg_value(i32 5, [[META7:![0-9]+]], !DIExpression(), [[META9:![0-9]+]])451; CHECK-NEXT: store i1 true, ptr poison, align 1452; CHECK-NEXT: ret void453;454 %cmp1 = icmp eq i8 %x, 0455 %cmp2 = icmp ne i8 %x, 0456 tail call void @llvm.assume(i1 %cmp1)457 tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9458 tail call void @llvm.assume(i1 %cmp1)459 tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9460 tail call void @llvm.assume(i1 %cmp2)461 tail call void @llvm.dbg.value(metadata i32 5, metadata !1, metadata !DIExpression()), !dbg !9462 tail call void @llvm.assume(i1 %cmp2)463 ret void464}465 466; This would crash.467; Does it ever make sense to peek through a bitcast of the icmp operand?468 469define i32 @PR40940(<4 x i8> %x) {470; CHECK-LABEL: @PR40940(471; CHECK-NEXT: [[SHUF:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <4 x i32> <i32 1, i32 1, i32 2, i32 3>472; CHECK-NEXT: [[T2:%.*]] = bitcast <4 x i8> [[SHUF]] to i32473; CHECK-NEXT: [[T3:%.*]] = icmp ult i32 [[T2]], 65536474; CHECK-NEXT: call void @llvm.assume(i1 [[T3]])475; CHECK-NEXT: ret i32 [[T2]]476;477 %shuf = shufflevector <4 x i8> %x, <4 x i8> undef, <4 x i32> <i32 1, i32 1, i32 2, i32 3>478 %t2 = bitcast <4 x i8> %shuf to i32479 %t3 = icmp ult i32 %t2, 65536480 call void @llvm.assume(i1 %t3)481 ret i32 %t2482}483 484define i1 @nonnull3A(ptr %a, i1 %control) {485; DEFAULT-LABEL: @nonnull3A(486; DEFAULT-NEXT: entry:487; DEFAULT-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8488; DEFAULT-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]489; DEFAULT: taken:490; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null491; DEFAULT-NEXT: call void @llvm.assume(i1 [[CMP]])492; DEFAULT-NEXT: ret i1 [[CMP]]493; DEFAULT: not_taken:494; DEFAULT-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null495; DEFAULT-NEXT: ret i1 [[RVAL_2]]496;497; BUNDLES-LABEL: @nonnull3A(498; BUNDLES-NEXT: entry:499; BUNDLES-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]500; BUNDLES: taken:501; BUNDLES-NEXT: ret i1 true502; BUNDLES: not_taken:503; BUNDLES-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8504; BUNDLES-NEXT: [[RVAL_2:%.*]] = icmp sgt ptr [[LOAD]], null505; BUNDLES-NEXT: ret i1 [[RVAL_2]]506;507entry:508 %load = load ptr, ptr %a509 %cmp = icmp ne ptr %load, null510 br i1 %control, label %taken, label %not_taken511taken:512 call void @llvm.assume(i1 %cmp)513 ret i1 %cmp514not_taken:515 call void @llvm.assume(i1 %cmp)516 %rval.2 = icmp sgt ptr %load, null517 ret i1 %rval.2518}519 520define i1 @nonnull3B(ptr %a, i1 %control) {521; CHECK-LABEL: @nonnull3B(522; CHECK-NEXT: entry:523; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8524; CHECK-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]525; CHECK: taken:526; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]527; CHECK-NEXT: ret i1 true528; CHECK: not_taken:529; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[LOAD]]) ]530; CHECK-NEXT: ret i1 false531;532entry:533 %load = load ptr, ptr %a534 %cmp = icmp ne ptr %load, null535 br i1 %control, label %taken, label %not_taken536taken:537 call void @llvm.assume(i1 true) ["nonnull"(ptr %load)]538 ret i1 %cmp539not_taken:540 call void @llvm.assume(i1 true) ["nonnull"(ptr %load)]541 ret i1 %control542}543 544declare i1 @tmp1(i1)545 546define i1 @nonnull3C(ptr %a, i1 %control) {547; CHECK-LABEL: @nonnull3C(548; CHECK-NEXT: entry:549; CHECK-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]550; CHECK: taken:551; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8552; CHECK-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null553; CHECK-NEXT: [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])554; CHECK-NEXT: br label [[EXIT:%.*]]555; CHECK: exit:556; CHECK-NEXT: ret i1 [[CMP2]]557; CHECK: not_taken:558; CHECK-NEXT: ret i1 false559;560entry:561 %load = load ptr, ptr %a562 %cmp = icmp ne ptr %load, null563 br i1 %control, label %taken, label %not_taken564taken:565 %cmp2 = call i1 @tmp1(i1 %cmp)566 br label %exit567exit:568 ; FIXME: this shouldn't be dropped because it is still dominated by the new position of %load569 call void @llvm.assume(i1 %cmp)570 ret i1 %cmp2571not_taken:572 call void @llvm.assume(i1 %cmp)573 ret i1 %control574}575 576define i1 @nonnull3D(ptr %a, i1 %control) {577; CHECK-LABEL: @nonnull3D(578; CHECK-NEXT: entry:579; CHECK-NEXT: br i1 [[CONTROL:%.*]], label [[TAKEN:%.*]], label [[NOT_TAKEN:%.*]]580; CHECK: taken:581; CHECK-NEXT: [[LOAD:%.*]] = load ptr, ptr [[A:%.*]], align 8582; CHECK-NEXT: [[CMP:%.*]] = icmp ne ptr [[LOAD]], null583; CHECK-NEXT: [[CMP2:%.*]] = call i1 @tmp1(i1 [[CMP]])584; CHECK-NEXT: br label [[EXIT:%.*]]585; CHECK: exit:586; CHECK-NEXT: ret i1 [[CMP2]]587; CHECK: not_taken:588; CHECK-NEXT: ret i1 false589;590entry:591 %load = load ptr, ptr %a592 %cmp = icmp ne ptr %load, null593 br i1 %control, label %taken, label %not_taken594taken:595 %cmp2 = call i1 @tmp1(i1 %cmp)596 br label %exit597exit:598 ret i1 %cmp2599not_taken:600 call void @llvm.assume(i1 %cmp)601 ret i1 %control602}603 604define void @nonnull_only_ephemeral_use(ptr %p) {605; DEFAULT-LABEL: @nonnull_only_ephemeral_use(606; DEFAULT-NEXT: [[A:%.*]] = load ptr, ptr [[P:%.*]], align 8607; DEFAULT-NEXT: [[CMP:%.*]] = icmp ne ptr [[A]], null608; DEFAULT-NEXT: tail call void @llvm.assume(i1 [[CMP]])609; DEFAULT-NEXT: ret void610;611; BUNDLES-LABEL: @nonnull_only_ephemeral_use(612; BUNDLES-NEXT: [[A:%.*]] = load ptr, ptr [[P:%.*]], align 8613; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(ptr [[A]]) ]614; BUNDLES-NEXT: ret void615;616 %a = load ptr, ptr %p617 %cmp = icmp ne ptr %a, null618 tail call void @llvm.assume(i1 %cmp)619 ret void620}621 622define void @always_true_assumption() {623; CHECK-LABEL: @always_true_assumption(624; CHECK-NEXT: ret void625;626 call void @llvm.assume(i1 true)627 ret void628}629 630; The alloca guarantees that the low bits of %a are zero because of alignment.631; The assume says the opposite. Make sure we don't crash.632 633define i64 @PR31809() {634; CHECK-LABEL: @PR31809(635; CHECK-NEXT: store i1 true, ptr poison, align 1636; CHECK-NEXT: ret i64 poison637;638 %a = alloca i32639 %t1 = ptrtoint ptr %a to i64640 %cond = icmp eq i64 %t1, 3641 call void @llvm.assume(i1 %cond)642 ret i64 %t1643}644 645; Similar to above: there's no way to know which assumption is truthful,646; so just don't crash.647 648define i8 @conflicting_assumptions(i8 %x){649; CHECK-LABEL: @conflicting_assumptions(650; CHECK-NEXT: store i1 true, ptr poison, align 1651; CHECK-NEXT: ret i8 poison652;653 %add = add i8 %x, 1654 %cond1 = icmp eq i8 %x, 3655 call void @llvm.assume(i1 %cond1)656 %cond2 = icmp eq i8 %x, 4657 call void @llvm.assume(i1 %cond2)658 ret i8 %add659}660 661; Another case of conflicting assumptions. This would crash because we'd662; try to set more known bits than existed in the known bits struct.663 664define void @PR36270(i32 %b) {665; CHECK-LABEL: @PR36270(666; CHECK-NEXT: unreachable667;668 %B7 = xor i32 -1, 2147483647669 %and1 = and i32 %b, 3670 %B12 = lshr i32 %B7, %and1671 %C1 = icmp ult i32 %and1, %B12672 tail call void @llvm.assume(i1 %C1)673 %cmp2 = icmp eq i32 0, %B12674 tail call void @llvm.assume(i1 %cmp2)675 unreachable676}677 678; PR47416679 680define i32 @unreachable_assume(i32 %x, i32 %y) {681; CHECK-LABEL: @unreachable_assume(682; CHECK-NEXT: entry:683; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1684; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1685; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]]686; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]])687; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1688; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]689; CHECK: if:690; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2691; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104692; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]])693; CHECK-NEXT: br label [[EXIT]]694; CHECK: exit:695; CHECK-NEXT: unreachable696;697entry:698 %cmp0 = icmp sgt i32 %x, 1699 %cmp1 = icmp eq i32 %y, 1700 %or = or i1 %cmp0, %cmp1701 tail call void @llvm.assume(i1 %or)702 %cmp2 = icmp eq i32 %x, 1703 br i1 %cmp2, label %if, label %exit704 705if:706 %a = and i32 %y, -2707 %cmp3 = icmp ne i32 %a, 104708 tail call void @llvm.assume(i1 %cmp3)709 br label %exit710 711exit:712 %cmp4 = icmp eq i32 %x, 2713 tail call void @llvm.assume(i1 %cmp4)714 unreachable715}716 717define i32 @unreachable_assume_logical(i32 %x, i32 %y) {718; CHECK-LABEL: @unreachable_assume_logical(719; CHECK-NEXT: entry:720; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1721; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1722; CHECK-NEXT: [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]]723; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]])724; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1725; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]726; CHECK: if:727; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2728; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104729; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]])730; CHECK-NEXT: br label [[EXIT]]731; CHECK: exit:732; CHECK-NEXT: unreachable733;734entry:735 %cmp0 = icmp sgt i32 %x, 1736 %cmp1 = icmp eq i32 %y, 1737 %or = select i1 %cmp0, i1 true, i1 %cmp1738 tail call void @llvm.assume(i1 %or)739 %cmp2 = icmp eq i32 %x, 1740 br i1 %cmp2, label %if, label %exit741 742if:743 %a = and i32 %y, -2744 %cmp3 = icmp ne i32 %a, 104745 tail call void @llvm.assume(i1 %cmp3)746 br label %exit747 748exit:749 %cmp4 = icmp eq i32 %x, 2750 tail call void @llvm.assume(i1 %cmp4)751 unreachable752}753 754define i32 @unreachable_assumes_and_store(i32 %x, i32 %y, ptr %p) {755; CHECK-LABEL: @unreachable_assumes_and_store(756; CHECK-NEXT: entry:757; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1758; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1759; CHECK-NEXT: [[OR:%.*]] = or i1 [[CMP0]], [[CMP1]]760; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]])761; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1762; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]763; CHECK: if:764; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2765; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104766; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]])767; CHECK-NEXT: br label [[EXIT]]768; CHECK: exit:769; CHECK-NEXT: unreachable770;771entry:772 %cmp0 = icmp sgt i32 %x, 1773 %cmp1 = icmp eq i32 %y, 1774 %or = or i1 %cmp0, %cmp1775 tail call void @llvm.assume(i1 %or)776 %cmp2 = icmp eq i32 %x, 1777 br i1 %cmp2, label %if, label %exit778 779if:780 %a = and i32 %y, -2781 %cmp3 = icmp ne i32 %a, 104782 tail call void @llvm.assume(i1 %cmp3)783 br label %exit784 785exit:786 %cmp4 = icmp eq i32 %x, 2787 tail call void @llvm.assume(i1 %cmp4)788 %cmp5 = icmp ugt i32 %y, 42789 tail call void @llvm.assume(i1 %cmp5)790 store i32 %x, ptr %p791 unreachable792}793 794define i32 @unreachable_assumes_and_store_logical(i32 %x, i32 %y, ptr %p) {795; CHECK-LABEL: @unreachable_assumes_and_store_logical(796; CHECK-NEXT: entry:797; CHECK-NEXT: [[CMP0:%.*]] = icmp sgt i32 [[X:%.*]], 1798; CHECK-NEXT: [[CMP1:%.*]] = icmp eq i32 [[Y:%.*]], 1799; CHECK-NEXT: [[OR:%.*]] = select i1 [[CMP0]], i1 true, i1 [[CMP1]]800; CHECK-NEXT: tail call void @llvm.assume(i1 [[OR]])801; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X]], 1802; CHECK-NEXT: br i1 [[CMP2]], label [[IF:%.*]], label [[EXIT:%.*]]803; CHECK: if:804; CHECK-NEXT: [[A:%.*]] = and i32 [[Y]], -2805; CHECK-NEXT: [[CMP3:%.*]] = icmp ne i32 [[A]], 104806; CHECK-NEXT: tail call void @llvm.assume(i1 [[CMP3]])807; CHECK-NEXT: br label [[EXIT]]808; CHECK: exit:809; CHECK-NEXT: unreachable810;811entry:812 %cmp0 = icmp sgt i32 %x, 1813 %cmp1 = icmp eq i32 %y, 1814 %or = select i1 %cmp0, i1 true, i1 %cmp1815 tail call void @llvm.assume(i1 %or)816 %cmp2 = icmp eq i32 %x, 1817 br i1 %cmp2, label %if, label %exit818 819if:820 %a = and i32 %y, -2821 %cmp3 = icmp ne i32 %a, 104822 tail call void @llvm.assume(i1 %cmp3)823 br label %exit824 825exit:826 %cmp4 = icmp eq i32 %x, 2827 tail call void @llvm.assume(i1 %cmp4)828 %cmp5 = icmp ugt i32 %y, 42829 tail call void @llvm.assume(i1 %cmp5)830 store i32 %x, ptr %p831 unreachable832}833 834define void @canonicalize_assume(ptr %0) {835; DEFAULT-LABEL: @canonicalize_assume(836; DEFAULT-NEXT: [[TMP2:%.*]] = getelementptr inbounds nuw i8, ptr [[TMP0:%.*]], i64 8837; DEFAULT-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[TMP2]], i64 16) ]838; DEFAULT-NEXT: ret void839;840; BUNDLES-LABEL: @canonicalize_assume(841; BUNDLES-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[TMP0:%.*]], i64 8) ]842; BUNDLES-NEXT: ret void843;844 %2 = getelementptr inbounds i32, ptr %0, i64 2845 call void @llvm.assume(i1 true) [ "align"(ptr %2, i64 16) ]846 ret void847}848 849define void @assume_makes_and_known_assume_on_arg(ptr %p, i32 %x) {850; CHECK-LABEL: @assume_makes_and_known_assume_on_arg(851; CHECK-NEXT: [[AND:%.*]] = and i32 [[X:%.*]], 1852; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0853; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])854; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4855; CHECK-NEXT: ret void856;857 %and = and i32 %x, 1858 %cmp = icmp eq i32 %and, 0859 call void @llvm.assume(i1 %cmp)860 %and2 = and i32 %x, 1861 store i32 %and2, ptr %p862 ret void863}864 865define void @assume_makes_and_known_assume_on_mul(ptr %p, i32 %a, i32 %b) {866; CHECK-LABEL: @assume_makes_and_known_assume_on_mul(867; CHECK-NEXT: [[X:%.*]] = mul i32 [[A:%.*]], [[B:%.*]]868; CHECK-NEXT: [[AND:%.*]] = and i32 [[X]], 1869; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0870; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])871; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4872; CHECK-NEXT: ret void873;874 %x = mul i32 %a, %b875 %and = and i32 %x, 1876 %cmp = icmp eq i32 %and, 0877 call void @llvm.assume(i1 %cmp)878 %and2 = and i32 %x, 1879 store i32 %and2, ptr %p880 ret void881}882 883define void @assume_makes_and_known_assume_on_bitwise(ptr %p, i32 %a, i32 %b) {884; CHECK-LABEL: @assume_makes_and_known_assume_on_bitwise(885; CHECK-NEXT: [[X:%.*]] = or i32 [[A:%.*]], [[B:%.*]]886; CHECK-NEXT: [[AND:%.*]] = and i32 [[X]], 1887; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[AND]], 0888; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])889; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4890; CHECK-NEXT: ret void891;892 %x = or i32 %a, %b893 %and = and i32 %x, 1894 %cmp = icmp eq i32 %and, 0895 call void @llvm.assume(i1 %cmp)896 %and2 = and i32 %x, 1897 store i32 %and2, ptr %p898 ret void899}900 901define i32 @range_16_31_top28(i32 %x) {902; CHECK-LABEL: @range_16_31_top28(903; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[X:%.*]], -16904; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], 16905; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])906; CHECK-NEXT: ret i32 16907;908 %add = add i32 %x, -16909 %cmp = icmp ult i32 %add, 16910 call void @llvm.assume(i1 %cmp)911 %res = and i32 %x, u0xfffffff0912 ret i32 %res913}914 915define i32 @range_16_31_top29(i32 %x) {916; CHECK-LABEL: @range_16_31_top29(917; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[X:%.*]], -16918; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[TMP1]], 16919; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])920; CHECK-NEXT: [[RES:%.*]] = and i32 [[X]], 24921; CHECK-NEXT: ret i32 [[RES]]922;923 %add = add i32 %x, -16924 %cmp = icmp ult i32 %add, 16925 call void @llvm.assume(i1 %cmp)926 %res = and i32 %x, u0xfffffff8927 ret i32 %res928}929 930define i32 @range_16_30_top28(i32 %x) {931; CHECK-LABEL: @range_16_30_top28(932; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -16933; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 15934; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])935; CHECK-NEXT: ret i32 16936;937 %add = add i32 %x, -16938 %cmp = icmp ult i32 %add, 15939 call void @llvm.assume(i1 %cmp)940 %res = and i32 %x, u0xfffffff0941 ret i32 %res942}943 944define i32 @range_16_32_top28(i32 %x) {945; CHECK-LABEL: @range_16_32_top28(946; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -16947; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 17948; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])949; CHECK-NEXT: [[RES:%.*]] = and i32 [[X]], 48950; CHECK-NEXT: ret i32 [[RES]]951;952 %add = add i32 %x, -16953 %cmp = icmp ult i32 %add, 17954 call void @llvm.assume(i1 %cmp)955 %res = and i32 %x, u0xfffffff0956 ret i32 %res957}958 959define i32 @range_16_32_top27(i32 %x) {960; CHECK-LABEL: @range_16_32_top27(961; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -16962; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 17963; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])964; CHECK-NEXT: [[RES:%.*]] = and i32 [[X]], 32965; CHECK-NEXT: ret i32 [[RES]]966;967 %add = add i32 %x, -16968 %cmp = icmp ult i32 %add, 17969 call void @llvm.assume(i1 %cmp)970 %res = and i32 %x, u0xffffffe0971 ret i32 %res972}973 974define i32 @range_16_32_top26(i32 %x) {975; CHECK-LABEL: @range_16_32_top26(976; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -16977; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 17978; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])979; CHECK-NEXT: ret i32 0980;981 %add = add i32 %x, -16982 %cmp = icmp ult i32 %add, 17983 call void @llvm.assume(i1 %cmp)984 %res = and i32 %x, u0xffffffc0985 ret i32 %res986}987 988define i32 @range_15_31_top28(i32 %x) {989; CHECK-LABEL: @range_15_31_top28(990; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -15991; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 16992; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])993; CHECK-NEXT: [[RES:%.*]] = and i32 [[X]], 16994; CHECK-NEXT: ret i32 [[RES]]995;996 %add = add i32 %x, -15997 %cmp = icmp ult i32 %add, 16998 call void @llvm.assume(i1 %cmp)999 %res = and i32 %x, u0xfffffff01000 ret i32 %res1001}1002 1003define i32 @range_15_31_top27(i32 %x) {1004; CHECK-LABEL: @range_15_31_top27(1005; CHECK-NEXT: [[ADD:%.*]] = add i32 [[X:%.*]], -151006; CHECK-NEXT: [[CMP:%.*]] = icmp ult i32 [[ADD]], 161007; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]])1008; CHECK-NEXT: ret i32 01009;1010 %add = add i32 %x, -151011 %cmp = icmp ult i32 %add, 161012 call void @llvm.assume(i1 %cmp)1013 %res = and i32 %x, u0xffffffe01014 ret i32 %res1015}1016 1017define i1 @not_cond_use(i8 %x) {1018; CHECK-LABEL: @not_cond_use(1019; CHECK-NEXT: [[CMP:%.*]] = icmp eq i8 [[X:%.*]], 01020; CHECK-NEXT: tail call void @use(i1 [[CMP]])1021; CHECK-NEXT: [[NOT:%.*]] = xor i1 [[CMP]], true1022; CHECK-NEXT: tail call void @llvm.assume(i1 [[NOT]])1023; CHECK-NEXT: [[RVAL:%.*]] = icmp eq i8 [[X]], 01024; CHECK-NEXT: ret i1 [[RVAL]]1025;1026 %cmp = icmp eq i8 %x, 01027 tail call void @use(i1 %cmp)1028 %not = xor i1 %cmp, true1029 tail call void @llvm.assume(i1 %not)1030 %rval = icmp eq i8 %x, 01031 ret i1 %rval1032}1033 1034define i1 @assume_trunc_nuw_eq_one(i8 %x) {1035; CHECK-LABEL: @assume_trunc_nuw_eq_one(1036; CHECK-NEXT: [[A:%.*]] = trunc nuw i8 [[X:%.*]] to i11037; CHECK-NEXT: call void @llvm.assume(i1 [[A]])1038; CHECK-NEXT: ret i1 true1039;1040 %a = trunc nuw i8 %x to i11041 call void @llvm.assume(i1 %a)1042 %q = icmp eq i8 %x, 11043 ret i1 %q1044}1045 1046define i1 @neg_assume_trunc_eq_one(i8 %x) {1047; CHECK-LABEL: @neg_assume_trunc_eq_one(1048; CHECK-NEXT: [[A:%.*]] = trunc i8 [[X:%.*]] to i11049; CHECK-NEXT: call void @llvm.assume(i1 [[A]])1050; CHECK-NEXT: [[Q:%.*]] = icmp eq i8 [[X]], 11051; CHECK-NEXT: ret i1 [[Q]]1052;1053 %a = trunc i8 %x to i11054 call void @llvm.assume(i1 %a)1055 %q = icmp eq i8 %x, 11056 ret i1 %q1057}1058 1059declare void @use(i1)1060declare void @llvm.dbg.value(metadata, metadata, metadata)1061 1062!llvm.dbg.cu = !{!0}1063!llvm.module.flags = !{!5, !6, !7, !8}1064 1065!0 = distinct !DICompileUnit(language: DW_LANG_C, file: !3, producer: "Me", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: null, retainedTypes: null, imports: null)1066!1 = !DILocalVariable(name: "", arg: 1, scope: !2, file: null, line: 1, type: null)1067!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)1068!3 = !DIFile(filename: "consecutive-fences.ll", directory: "")1069!5 = !{i32 2, !"Dwarf Version", i32 4}1070!6 = !{i32 2, !"Debug Info Version", i32 3}1071!7 = !{i32 1, !"wchar_size", i32 4}1072!8 = !{i32 7, !"PIC Level", i32 2}1073!9 = !DILocation(line: 0, column: 0, scope: !2)1074 1075 1076attributes #0 = { nounwind uwtable }1077attributes #1 = { nounwind }1078 1079