| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py |
| ; RUN: opt -S -early-cse -earlycse-debug-hash < %s | FileCheck %s --check-prefixes=CHECK,NO_ASSUME |
| ; RUN: opt < %s -S -basic-aa -early-cse-memssa | FileCheck %s --check-prefixes=CHECK,NO_ASSUME |
| ; RUN: opt < %s -S -basic-aa -early-cse-memssa --enable-knowledge-retention | FileCheck %s --check-prefixes=CHECK,USE_ASSUME |
| |
| declare void @llvm.experimental.guard(i1,...) |
| |
| declare void @llvm.assume(i1) |
| |
| define i32 @test0(i32* %ptr, i1 %cond) { |
| ; We can do store to load forwarding over a guard, since it does not |
| ; clobber memory |
| ; NO_ASSUME-LABEL: @test0( |
| ; NO_ASSUME-NEXT: store i32 40, i32* [[PTR:%.*]], align 4 |
| ; NO_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"() ] |
| ; NO_ASSUME-NEXT: ret i32 40 |
| ; |
| ; USE_ASSUME-LABEL: @test0( |
| ; USE_ASSUME-NEXT: store i32 40, i32* [[PTR:%.*]], align 4 |
| ; USE_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"() ] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[PTR]], i64 4), "nonnull"(i32* [[PTR]]), "align"(i32* [[PTR]], i64 4) ] |
| ; USE_ASSUME-NEXT: ret i32 40 |
| ; |
| |
| store i32 40, i32* %ptr |
| call void(i1,...) @llvm.experimental.guard(i1 %cond) [ "deopt"() ] |
| %rval = load i32, i32* %ptr |
| ret i32 %rval |
| } |
| |
| define i32 @test1(i32* %val, i1 %cond) { |
| ; We can CSE loads over a guard, since it does not clobber memory |
| ; NO_ASSUME-LABEL: @test1( |
| ; NO_ASSUME-NEXT: [[VAL0:%.*]] = load i32, i32* [[VAL:%.*]], align 4 |
| ; NO_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"() ] |
| ; NO_ASSUME-NEXT: ret i32 0 |
| ; |
| ; USE_ASSUME-LABEL: @test1( |
| ; USE_ASSUME-NEXT: [[VAL0:%.*]] = load i32, i32* [[VAL:%.*]], align 4 |
| ; USE_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND:%.*]]) [ "deopt"() ] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[VAL]], i64 4), "nonnull"(i32* [[VAL]]), "align"(i32* [[VAL]], i64 4) ] |
| ; USE_ASSUME-NEXT: ret i32 0 |
| ; |
| |
| %val0 = load i32, i32* %val |
| call void(i1,...) @llvm.experimental.guard(i1 %cond) [ "deopt"() ] |
| %val1 = load i32, i32* %val |
| %rval = sub i32 %val0, %val1 |
| ret i32 %rval |
| } |
| |
| define i32 @test2() { |
| ; Guards on "true" get removed |
| ; CHECK-LABEL: @test2( |
| ; CHECK-NEXT: ret i32 0 |
| ; |
| call void(i1, ...) @llvm.experimental.guard(i1 true) [ "deopt"() ] |
| ret i32 0 |
| } |
| |
| define i32 @test3(i32 %val) { |
| ; After a guard has executed the condition it was guarding is known to |
| ; be true. |
| ; CHECK-LABEL: @test3( |
| ; CHECK-NEXT: [[COND0:%.*]] = icmp slt i32 [[VAL:%.*]], 40 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND0]]) [ "deopt"() ] |
| ; CHECK-NEXT: ret i32 -1 |
| ; |
| |
| %cond0 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond0) [ "deopt"() ] |
| %cond1 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ] |
| |
| %cond2 = icmp slt i32 %val, 40 |
| %rval = sext i1 %cond2 to i32 |
| ret i32 %rval |
| } |
| |
| define i32 @test3.unhandled(i32 %val) { |
| ; After a guard has executed the condition it was guarding is known to |
| ; be true. |
| ; CHECK-LABEL: @test3.unhandled( |
| ; CHECK-NEXT: [[COND0:%.*]] = icmp slt i32 [[VAL:%.*]], 40 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND0]]) [ "deopt"() ] |
| ; CHECK-NEXT: [[COND1:%.*]] = icmp sge i32 [[VAL]], 40 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND1]]) [ "deopt"() ] |
| ; CHECK-NEXT: ret i32 0 |
| ; |
| |
| ; Demonstrates a case we do not yet handle (it is legal to fold %cond2 |
| ; to false) |
| %cond0 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond0) [ "deopt"() ] |
| %cond1 = icmp sge i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ] |
| ret i32 0 |
| } |
| |
| define i32 @test4(i32 %val, i1 %c) { |
| ; Same as test3, but with some control flow involved. |
| ; CHECK-LABEL: @test4( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[COND0:%.*]] = icmp slt i32 [[VAL:%.*]], 40 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND0]]) [ "deopt"() ] |
| ; CHECK-NEXT: br label [[BB0:%.*]] |
| ; CHECK: bb0: |
| ; CHECK-NEXT: [[COND2:%.*]] = icmp ult i32 [[VAL]], 200 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND2]]) [ "deopt"() ] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[LEFT:%.*]], label [[RIGHT:%.*]] |
| ; CHECK: left: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: right: |
| ; CHECK-NEXT: ret i32 20 |
| ; |
| |
| |
| |
| |
| entry: |
| %cond0 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond0) [ "deopt"() ] |
| %cond1 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ] |
| br label %bb0 |
| |
| bb0: |
| %cond2 = icmp ult i32 %val, 200 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond2) [ "deopt"() ] |
| br i1 %c, label %left, label %right |
| |
| left: |
| %cond3 = icmp ult i32 %val, 200 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond3) [ "deopt"() ] |
| ret i32 0 |
| |
| right: |
| ret i32 20 |
| } |
| |
| define i32 @test5(i32 %val, i1 %c) { |
| ; Same as test4, but the %left block has mutliple predecessors. |
| ; CHECK-LABEL: @test5( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[COND0:%.*]] = icmp slt i32 [[VAL:%.*]], 40 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND0]]) [ "deopt"() ] |
| ; CHECK-NEXT: br label [[BB0:%.*]] |
| ; CHECK: bb0: |
| ; CHECK-NEXT: [[COND2:%.*]] = icmp ult i32 [[VAL]], 200 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND2]]) [ "deopt"() ] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[LEFT:%.*]], label [[RIGHT:%.*]] |
| ; CHECK: left: |
| ; CHECK-NEXT: br label [[RIGHT]] |
| ; CHECK: right: |
| ; CHECK-NEXT: br label [[LEFT]] |
| ; |
| |
| |
| |
| |
| |
| entry: |
| %cond0 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond0) [ "deopt"() ] |
| %cond1 = icmp slt i32 %val, 40 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ] |
| br label %bb0 |
| |
| bb0: |
| %cond2 = icmp ult i32 %val, 200 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond2) [ "deopt"() ] |
| br i1 %c, label %left, label %right |
| |
| left: |
| %cond3 = icmp ult i32 %val, 200 |
| call void(i1,...) @llvm.experimental.guard(i1 %cond3) [ "deopt"() ] |
| br label %right |
| |
| right: |
| br label %left |
| } |
| |
| define void @test6(i1 %c, i32* %ptr) { |
| ; Check that we do not DSE over calls to @llvm.experimental.guard. |
| ; Guard intrinsics do _read_ memory, so th call to guard below needs |
| ; to see the store of 500 to %ptr |
| ; CHECK-LABEL: @test6( |
| ; CHECK-NEXT: store i32 500, i32* [[PTR:%.*]], align 4 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[C:%.*]]) [ "deopt"() ] |
| ; CHECK-NEXT: store i32 600, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: ret void |
| ; |
| |
| |
| store i32 500, i32* %ptr |
| call void(i1,...) @llvm.experimental.guard(i1 %c) [ "deopt"() ] |
| store i32 600, i32* %ptr |
| ret void |
| } |
| |
| define void @test07(i32 %a, i32 %b) { |
| ; Check that we are able to remove the guards on the same condition even if the |
| ; condition is not being recalculated. |
| ; CHECK-LABEL: @test07( |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; CHECK-NEXT: ret void |
| ; |
| |
| %cmp = icmp eq i32 %a, %b |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| ret void |
| } |
| |
| define void @test08(i32 %a, i32 %b, i32* %ptr) { |
| ; Check that we deal correctly with stores when removing guards in the same |
| ; block in case when the condition is not recalculated. |
| ; NO_ASSUME-LABEL: @test08( |
| ; NO_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; NO_ASSUME-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; NO_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; NO_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: ret void |
| ; |
| ; USE_ASSUME-LABEL: @test08( |
| ; USE_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; USE_ASSUME-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; USE_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[PTR]], i64 4), "nonnull"(i32* [[PTR]]), "align"(i32* [[PTR]], i64 4) ] |
| ; USE_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: ret void |
| ; |
| |
| %cmp = icmp eq i32 %a, %b |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 200, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| ret void |
| } |
| |
| define void @test09(i32 %a, i32 %b, i1 %c, i32* %ptr) { |
| ; Similar to test08, but with more control flow. |
| ; TODO: Can we get rid of the store in the end of entry given that it is |
| ; post-dominated by other stores? |
| ; NO_ASSUME-LABEL: @test09( |
| ; NO_ASSUME-NEXT: entry: |
| ; NO_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; NO_ASSUME-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; NO_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; NO_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; NO_ASSUME: if.true: |
| ; NO_ASSUME-NEXT: store i32 500, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: br label [[MERGE:%.*]] |
| ; NO_ASSUME: if.false: |
| ; NO_ASSUME-NEXT: store i32 600, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: br label [[MERGE]] |
| ; NO_ASSUME: merge: |
| ; NO_ASSUME-NEXT: ret void |
| ; |
| ; USE_ASSUME-LABEL: @test09( |
| ; USE_ASSUME-NEXT: entry: |
| ; USE_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; USE_ASSUME-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; USE_ASSUME-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[PTR]], i64 4), "nonnull"(i32* [[PTR]]), "align"(i32* [[PTR]], i64 4) ] |
| ; USE_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; USE_ASSUME: if.true: |
| ; USE_ASSUME-NEXT: store i32 500, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br label [[MERGE:%.*]] |
| ; USE_ASSUME: if.false: |
| ; USE_ASSUME-NEXT: store i32 600, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br label [[MERGE]] |
| ; USE_ASSUME: merge: |
| ; USE_ASSUME-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 200, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| br i1 %c, label %if.true, label %if.false |
| |
| if.true: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 500, i32* %ptr |
| br label %merge |
| |
| if.false: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 600, i32* %ptr |
| br label %merge |
| |
| merge: |
| ret void |
| } |
| |
| define void @test10(i32 %a, i32 %b, i1 %c, i32* %ptr) { |
| ; Make sure that non-dominating guards do not cause other guards removal. |
| ; CHECK-LABEL: @test10( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; CHECK: if.true: |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; CHECK-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; CHECK-NEXT: br label [[MERGE:%.*]] |
| ; CHECK: if.false: |
| ; CHECK-NEXT: store i32 200, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: br label [[MERGE]] |
| ; CHECK: merge: |
| ; CHECK-NEXT: store i32 300, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; CHECK-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| br i1 %c, label %if.true, label %if.false |
| |
| if.true: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| br label %merge |
| |
| if.false: |
| store i32 200, i32* %ptr |
| br label %merge |
| |
| merge: |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| ret void |
| } |
| |
| define void @test11(i32 %a, i32 %b, i32* %ptr) { |
| ; Make sure that branching condition is applied to guards. |
| ; CHECK-LABEL: @test11( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: br i1 [[CMP]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; CHECK: if.true: |
| ; CHECK-NEXT: br label [[MERGE:%.*]] |
| ; CHECK: if.false: |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 false) [ "deopt"() ] |
| ; CHECK-NEXT: br label [[MERGE]] |
| ; CHECK: merge: |
| ; CHECK-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| br i1 %cmp, label %if.true, label %if.false |
| |
| if.true: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| br label %merge |
| |
| if.false: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| br label %merge |
| |
| merge: |
| ret void |
| } |
| |
| define void @test12(i32 %a, i32 %b) { |
| ; Check that the assume marks its condition as being true (and thus allows to |
| ; eliminate the dominated guards). |
| ; CHECK-LABEL: @test12( |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: ret void |
| ; |
| |
| %cmp = icmp eq i32 %a, %b |
| call void @llvm.assume(i1 %cmp) |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| ret void |
| } |
| |
| define void @test13(i32 %a, i32 %b, i32* %ptr) { |
| ; Check that we deal correctly with stores when removing guards due to assume. |
| ; NO_ASSUME-LABEL: @test13( |
| ; NO_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; NO_ASSUME-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; NO_ASSUME-NEXT: store i32 400, i32* [[PTR:%.*]], align 4 |
| ; NO_ASSUME-NEXT: ret void |
| ; |
| ; USE_ASSUME-LABEL: @test13( |
| ; USE_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[PTR:%.*]], i64 4), "nonnull"(i32* [[PTR]]), "align"(i32* [[PTR]], i64 4) ] |
| ; USE_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: ret void |
| ; |
| |
| %cmp = icmp eq i32 %a, %b |
| call void @llvm.assume(i1 %cmp) |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 200, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| ret void |
| } |
| |
| define void @test14(i32 %a, i32 %b, i1 %c, i32* %ptr) { |
| ; Similar to test13, but with more control flow. |
| ; TODO: Can we get rid of the store in the end of entry given that it is |
| ; post-dominated by other stores? |
| ; NO_ASSUME-LABEL: @test14( |
| ; NO_ASSUME-NEXT: entry: |
| ; NO_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; NO_ASSUME-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; NO_ASSUME-NEXT: store i32 400, i32* [[PTR:%.*]], align 4 |
| ; NO_ASSUME-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; NO_ASSUME: if.true: |
| ; NO_ASSUME-NEXT: store i32 500, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: br label [[MERGE:%.*]] |
| ; NO_ASSUME: if.false: |
| ; NO_ASSUME-NEXT: store i32 600, i32* [[PTR]], align 4 |
| ; NO_ASSUME-NEXT: br label [[MERGE]] |
| ; NO_ASSUME: merge: |
| ; NO_ASSUME-NEXT: ret void |
| ; |
| ; USE_ASSUME-LABEL: @test14( |
| ; USE_ASSUME-NEXT: entry: |
| ; USE_ASSUME-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; USE_ASSUME-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32* [[PTR:%.*]], i64 4), "nonnull"(i32* [[PTR]]), "align"(i32* [[PTR]], i64 4) ] |
| ; USE_ASSUME-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; USE_ASSUME: if.true: |
| ; USE_ASSUME-NEXT: store i32 500, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br label [[MERGE:%.*]] |
| ; USE_ASSUME: if.false: |
| ; USE_ASSUME-NEXT: store i32 600, i32* [[PTR]], align 4 |
| ; USE_ASSUME-NEXT: br label [[MERGE]] |
| ; USE_ASSUME: merge: |
| ; USE_ASSUME-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| call void @llvm.assume(i1 %cmp) |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 200, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| br i1 %c, label %if.true, label %if.false |
| |
| if.true: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 500, i32* %ptr |
| br label %merge |
| |
| if.false: |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 600, i32* %ptr |
| br label %merge |
| |
| merge: |
| ret void |
| } |
| |
| define void @test15(i32 %a, i32 %b, i1 %c, i32* %ptr) { |
| ; Make sure that non-dominating assumes do not cause guards removal. |
| ; CHECK-LABEL: @test15( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; CHECK: if.true: |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: store i32 100, i32* [[PTR:%.*]], align 4 |
| ; CHECK-NEXT: br label [[MERGE:%.*]] |
| ; CHECK: if.false: |
| ; CHECK-NEXT: store i32 200, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: br label [[MERGE]] |
| ; CHECK: merge: |
| ; CHECK-NEXT: store i32 300, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[CMP]]) [ "deopt"() ] |
| ; CHECK-NEXT: store i32 400, i32* [[PTR]], align 4 |
| ; CHECK-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| br i1 %c, label %if.true, label %if.false |
| |
| if.true: |
| call void @llvm.assume(i1 %cmp) |
| store i32 100, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| br label %merge |
| |
| if.false: |
| store i32 200, i32* %ptr |
| br label %merge |
| |
| merge: |
| store i32 300, i32* %ptr |
| call void (i1, ...) @llvm.experimental.guard(i1 %cmp) [ "deopt"() ] |
| store i32 400, i32* %ptr |
| ret void |
| } |
| |
| define void @test16(i32 %a, i32 %b) { |
| ; Check that we don't bother to do anything with assumes even if we know the |
| ; condition being true. |
| ; CHECK-LABEL: @test16( |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: ret void |
| ; |
| |
| %cmp = icmp eq i32 %a, %b |
| call void @llvm.assume(i1 %cmp) |
| call void @llvm.assume(i1 %cmp) |
| ret void |
| } |
| |
| define void @test17(i32 %a, i32 %b, i1 %c, i32* %ptr) { |
| ; Check that we don't bother to do anything with assumes even if we know the |
| ; condition being true or false (includes come control flow). |
| ; CHECK-LABEL: @test17( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[IF_TRUE:%.*]], label [[IF_FALSE:%.*]] |
| ; CHECK: if.true: |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: br label [[MERGE:%.*]] |
| ; CHECK: if.false: |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[CMP]]) |
| ; CHECK-NEXT: br label [[MERGE]] |
| ; CHECK: merge: |
| ; CHECK-NEXT: ret void |
| ; |
| |
| entry: |
| %cmp = icmp eq i32 %a, %b |
| br i1 %c, label %if.true, label %if.false |
| |
| if.true: |
| call void @llvm.assume(i1 %cmp) |
| br label %merge |
| |
| if.false: |
| call void @llvm.assume(i1 %cmp) |
| br label %merge |
| |
| merge: |
| ret void |
| } |
| |
| define void @test18(i1 %c) { |
| ; Check that we don't bother to do anything with assumes even if we know the |
| ; condition being true and not being an instruction. |
| ; CHECK-LABEL: @test18( |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[C:%.*]]) |
| ; CHECK-NEXT: call void @llvm.assume(i1 [[C]]) |
| ; CHECK-NEXT: ret void |
| ; |
| |
| call void @llvm.assume(i1 %c) |
| call void @llvm.assume(i1 %c) |
| ret void |
| } |
