This is an archive of the discontinued LLVM Phabricator instance.

Differential D106147

[PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types.
ClosedPublic

Authored by jeroen.dobbelaere on Jul 16 2021, 6:26 AM.

Details

Reviewers
jroelofs
fhahn
nikic
Commits
rG03b8c69d06f8: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types.
Summary

This is a second attempt to fix the EXPENSIVE_CHECKS issue that was mentioned In D91661#2875179 by @jroelofs.

(The first attempt was in D105983)

D91661 more or less completely reverted D49126 and by doing so also removed the cleanup logic of the created declarations and calls.
This patch is a replacement for D91661 (which must itself be reverted first). It only replaces the custom declaration creation with the generic version and shows the test impact.

Diff Detail

Event Timeline

jeroen.dobbelaere created this revision.Jul 16 2021, 6:26 AM
Herald added subscribers: ormris, hiraditya. · View Herald TranscriptJul 16 2021, 6:26 AM
jeroen.dobbelaere requested review of this revision.Jul 16 2021, 6:26 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 16 2021, 6:26 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B114482: Diff 359301.Jul 16 2021, 6:26 AM
nikic added a comment.Jul 16 2021, 9:48 AM

Won't this also remove the declaration if there's a pre-existing use?

jeroen.dobbelaere added a comment.Jul 19 2021, 12:36 AM
In D106147#2883575, @nikic wrote:

Won't this also remove the declaration if there's a pre-existing use?

No, but it might remove a declaration that is available but not used.

jeroen.dobbelaere updated this revision to Diff 359682.Jul 19 2021, 12:38 AM

Only track newly introduced declarations for removal. Do not use the 'use count' to decide this.

Herald added a subscriber: dexonsmith. · View Herald TranscriptJul 19 2021, 12:38 AM
Harbormaster completed remote builds in B114782: Diff 359682.Jul 19 2021, 12:38 AM
jeroen.dobbelaere added a comment.Jul 28 2021, 9:44 AM

ping

jroelofs accepted this revision.Jul 28 2021, 9:49 AM

LGTM

This revision is now accepted and ready to land.Jul 28 2021, 9:49 AM
This revision was landed with ongoing or failed builds.Jul 28 2021, 10:31 AM
Closed by commit rG03b8c69d06f8: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types. (authored by jeroen.dobbelaere). · Explain Why
This revision was automatically updated to reflect the committed changes.
jeroen.dobbelaere added a commit: rG03b8c69d06f8: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types..
fhahn added a comment.Aug 3 2021, 6:04 AM

thanks for pushing this through!

Revision Contents

PathSize
llvm/
include/
llvm/
IR/
3 lines
lib/
IR/
4 lines
Transforms/
Utils/
32 lines
test/
Other/
4 lines
Transforms/
Util/
PredicateInfo/
42 lines
8 lines
18 lines
208 lines
4 lines

Diff 362447

llvm/include/llvm/IR/Module.h

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 Lines
/// @name Generic Value Accessors /// @name Generic Value Accessors
/// @{ /// @{
/// Return the global value in the module with the specified name, of /// Return the global value in the module with the specified name, of
/// arbitrary type. This method returns null if a global with the specified /// arbitrary type. This method returns null if a global with the specified
/// name is not found. /// name is not found.
GlobalValue *getNamedValue(StringRef Name) const; GlobalValue *getNamedValue(StringRef Name) const;
/// Return the number of global values in the module.
unsigned getNumNamedValues() const;
/// Return a unique non-zero ID for the specified metadata kind. This ID is /// Return a unique non-zero ID for the specified metadata kind. This ID is
/// uniqued across modules in the current LLVMContext. /// uniqued across modules in the current LLVMContext.
unsigned getMDKindID(StringRef Name) const; unsigned getMDKindID(StringRef Name) const;
/// Populate client supplied SmallVector with the name for custom metadata IDs /// Populate client supplied SmallVector with the name for custom metadata IDs
/// registered in this LLVMContext. /// registered in this LLVMContext.
void getMDKindNames(SmallVectorImpl<StringRef> &Result) const; void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
▲ Show 20 Lines • Show All 627 Lines • Show Last 20 Lines

llvm/lib/IR/Module.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines
/// getNamedValue - Return the first global value in the module with /// getNamedValue - Return the first global value in the module with
/// the specified name, of arbitrary type. This method returns null /// the specified name, of arbitrary type. This method returns null
/// if a global with the specified name is not found. /// if a global with the specified name is not found.
GlobalValue *Module::getNamedValue(StringRef Name) const { GlobalValue *Module::getNamedValue(StringRef Name) const {
return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name)); return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
} }
unsigned Module::getNumNamedValues() const {
return getValueSymbolTable().size();
}
/// getMDKindID - Return a unique non-zero ID for the specified metadata kind. /// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
/// This ID is uniqued across modules in the current LLVMContext. /// This ID is uniqued across modules in the current LLVMContext.
unsigned Module::getMDKindID(StringRef Name) const { unsigned Module::getMDKindID(StringRef Name) const {
return Context.getMDKindID(Name); return Context.getMDKindID(Name);
} }
/// getMDKindNames - Populate client supplied SmallVector with the name for /// getMDKindNames - Populate client supplied SmallVector with the name for
/// custom metadata IDs registered in this LLVMContext. ID #0 is not used, /// custom metadata IDs registered in this LLVMContext. ID #0 is not used,
▲ Show 20 Lines • Show All 683 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/PredicateInfo.cpp

Show First 20 Lines • Show All 533 Lines • ▼ Show 20 Lines for (auto &Assume : AC.assumptions()) {
if (auto *II = dyn_cast_or_null<IntrinsicInst>(Assume)) if (auto *II = dyn_cast_or_null<IntrinsicInst>(Assume))
if (DT.isReachableFromEntry(II->getParent())) if (DT.isReachableFromEntry(II->getParent()))
processAssume(II, II->getParent(), OpsToRename); processAssume(II, II->getParent(), OpsToRename);
} }
// Now rename all our operations. // Now rename all our operations.
renameUses(OpsToRename); renameUses(OpsToRename);
} }
// Create a ssa_copy declaration with custom mangling, because
// Intrinsic::getDeclaration does not handle overloaded unnamed types properly:
// all unnamed types get mangled to the same string. We use the pointer
// to the type as name here, as it guarantees unique names for different
// types and we remove the declarations when destroying PredicateInfo.
// It is a workaround for PR38117, because solving it in a fully general way is
// tricky (FIXME).
static Function *getCopyDeclaration(Module *M, Type *Ty) {
std::string Name = "llvm.ssa.copy." + utostr((uintptr_t) Ty);
return cast<Function>(
M->getOrInsertFunction(Name,
getType(M->getContext(), Intrinsic::ssa_copy, Ty))
.getCallee());
}
// Given the renaming stack, make all the operands currently on the stack real // Given the renaming stack, make all the operands currently on the stack real
// by inserting them into the IR. Return the last operation's value. // by inserting them into the IR. Return the last operation's value.
Value *PredicateInfoBuilder::materializeStack(unsigned int &Counter, Value *PredicateInfoBuilder::materializeStack(unsigned int &Counter,
ValueDFSStack &RenameStack, ValueDFSStack &RenameStack,
Value *OrigOp) { Value *OrigOp) {
// Find the first thing we have to materialize // Find the first thing we have to materialize
auto RevIter = RenameStack.rbegin(); auto RevIter = RenameStack.rbegin();
for (; RevIter != RenameStack.rend(); ++RevIter) for (; RevIter != RenameStack.rend(); ++RevIter)
Show All 13 Lines for (auto RenameIter = RenameStack.end() - Start;
ValInfo->RenamedOp = (RenameStack.end() - Start) == RenameStack.begin() ValInfo->RenamedOp = (RenameStack.end() - Start) == RenameStack.begin()
? OrigOp ? OrigOp
: (RenameStack.end() - Start - 1)->Def; : (RenameStack.end() - Start - 1)->Def;
// For edge predicates, we can just place the operand in the block before // For edge predicates, we can just place the operand in the block before
// the terminator. For assume, we have to place it right before the assume // the terminator. For assume, we have to place it right before the assume
// to ensure we dominate all of our uses. Always insert right before the // to ensure we dominate all of our uses. Always insert right before the
// relevant instruction (terminator, assume), so that we insert in proper // relevant instruction (terminator, assume), so that we insert in proper
// order in the case of multiple predicateinfo in the same block. // order in the case of multiple predicateinfo in the same block.
// The number of named values is used to detect if a new declaration was
// added. If so, that declaration is tracked so that it can be removed when
// the analysis is done. The corner case were a new declaration results in
// a name clash and the old name being renamed is not considered as that
// represents an invalid module.
if (isa<PredicateWithEdge>(ValInfo)) { if (isa<PredicateWithEdge>(ValInfo)) {
IRBuilder<> B(getBranchTerminator(ValInfo)); IRBuilder<> B(getBranchTerminator(ValInfo));
Function *IF = getCopyDeclaration(F.getParent(), Op->getType()); auto NumDecls = F.getParent()->getNumNamedValues();
if (IF->users().empty()) Function *IF = Intrinsic::getDeclaration(
F.getParent(), Intrinsic::ssa_copy, Op->getType());
if (NumDecls != F.getParent()->getNumNamedValues())
PI.CreatedDeclarations.insert(IF); PI.CreatedDeclarations.insert(IF);
CallInst *PIC = CallInst *PIC =
B.CreateCall(IF, Op, Op->getName() + "." + Twine(Counter++)); B.CreateCall(IF, Op, Op->getName() + "." + Twine(Counter++));
PI.PredicateMap.insert({PIC, ValInfo}); PI.PredicateMap.insert({PIC, ValInfo});
Result.Def = PIC; Result.Def = PIC;
} else { } else {
auto *PAssume = dyn_cast<PredicateAssume>(ValInfo); auto *PAssume = dyn_cast<PredicateAssume>(ValInfo);
assert(PAssume && assert(PAssume &&
"Should not have gotten here without it being an assume"); "Should not have gotten here without it being an assume");
// Insert the predicate directly after the assume. While it also holds // Insert the predicate directly after the assume. While it also holds
// directly before it, assume(i1 true) is not a useful fact. // directly before it, assume(i1 true) is not a useful fact.
IRBuilder<> B(PAssume->AssumeInst->getNextNode()); IRBuilder<> B(PAssume->AssumeInst->getNextNode());
Function *IF = getCopyDeclaration(F.getParent(), Op->getType()); auto NumDecls = F.getParent()->getNumNamedValues();
if (IF->users().empty()) Function *IF = Intrinsic::getDeclaration(
F.getParent(), Intrinsic::ssa_copy, Op->getType());
if (NumDecls != F.getParent()->getNumNamedValues())
PI.CreatedDeclarations.insert(IF); PI.CreatedDeclarations.insert(IF);
CallInst *PIC = B.CreateCall(IF, Op); CallInst *PIC = B.CreateCall(IF, Op);
PI.PredicateMap.insert({PIC, ValInfo}); PI.PredicateMap.insert({PIC, ValInfo});
Result.Def = PIC; Result.Def = PIC;
} }
} }
return RenameStack.back().Def; return RenameStack.back().Def;
} }
▲ Show 20 Lines • Show All 351 Lines • Show Last 20 Lines

llvm/test/Other/debugcounter-predicateinfo.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -debug-counter=predicateinfo-rename-skip=1,predicateinfo-rename-count=1 -print-predicateinfo < %s 2>&1 | FileCheck %s ; RUN: opt -debug-counter=predicateinfo-rename-skip=1,predicateinfo-rename-count=1 -print-predicateinfo < %s 2>&1 | FileCheck %s
;; Test that, with debug counters on, we don't rename the first info, only the second ;; Test that, with debug counters on, we don't rename the first info, only the second
define fastcc void @barney() { define fastcc void @barney() {
; CHECK-LABEL: @barney( ; CHECK-LABEL: @barney(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: br label [[BB22:%.*]] ; CHECK-NEXT: br label [[BB22:%.*]]
; CHECK: bb22: ; CHECK: bb22:
; CHECK-NEXT: [[TMP23:%.*]] = icmp eq i32 undef, 2 ; CHECK-NEXT: [[TMP23:%.*]] = icmp eq i32 undef, 2
; CHECK: [[TMP23_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP23]]) ; CHECK: [[TMP23_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP23]])
; CHECK-NEXT: br i1 [[TMP23]], label [[BB29:%.*]], label [[BB35:%.*]] ; CHECK-NEXT: br i1 [[TMP23]], label [[BB29:%.*]], label [[BB35:%.*]]
; CHECK: bb29: ; CHECK: bb29:
; CHECK: [[TMP23_0_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP23_0]]) ; CHECK: [[TMP23_0_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP23_0]])
; CHECK-NEXT: br i1 [[TMP23]], label [[BB33:%.*]], label [[BB35]] ; CHECK-NEXT: br i1 [[TMP23]], label [[BB33:%.*]], label [[BB35]]
; CHECK: bb33: ; CHECK: bb33:
; CHECK-NEXT: br i1 [[TMP23_0_1]], label [[BB35]], label [[BB35]] ; CHECK-NEXT: br i1 [[TMP23_0_1]], label [[BB35]], label [[BB35]]
; CHECK: bb35: ; CHECK: bb35:
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; ;
bb: bb:
br label %bb22 br label %bb22
Show All 17 Lines

llvm/test/Transforms/Util/PredicateInfo/condprop.ll

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines
case3: case3:
call void @bar(i32 %x) call void @bar(i32 %x)
ret void ret void
} }
define i1 @test5(i32 %x, i32 %y) { define i1 @test5(i32 %x, i32 %y) {
; CHECK-LABEL: @test5( ; CHECK-LABEL: @test5(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
; CHECK: same: ; CHECK: same:
; CHECK-NEXT: [[CMP2:%.*]] = icmp ne i32 [[X_0]], [[Y_0]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp ne i32 [[X_0]], [[Y_0]]
; CHECK-NEXT: ret i1 [[CMP2]] ; CHECK-NEXT: ret i1 [[CMP2]]
; CHECK: different: ; CHECK: different:
; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i32 [[X_1]], [[Y_1]] ; CHECK-NEXT: [[CMP3:%.*]] = icmp eq i32 [[X_1]], [[Y_1]]
; CHECK-NEXT: ret i1 [[CMP3]] ; CHECK-NEXT: ret i1 [[CMP3]]
; ;
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
different: different:
ret i1 %cmp3 ret i1 %cmp3
} }
define i1 @test7(i32 %x, i32 %y) { define i1 @test7(i32 %x, i32 %y) {
; CHECK-LABEL: @test7( ; CHECK-LABEL: @test7(
; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp sgt i32 [[X:%.*]], [[Y:%.*]]
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
; CHECK: same: ; CHECK: same:
; CHECK-NEXT: [[CMP2:%.*]] = icmp sle i32 [[X_0]], [[Y_0]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp sle i32 [[X_0]], [[Y_0]]
; CHECK-NEXT: ret i1 [[CMP2]] ; CHECK-NEXT: ret i1 [[CMP2]]
; CHECK: different: ; CHECK: different:
; CHECK-NEXT: [[CMP3:%.*]] = icmp sgt i32 [[X_1]], [[Y_1]] ; CHECK-NEXT: [[CMP3:%.*]] = icmp sgt i32 [[X_1]], [[Y_1]]
; CHECK-NEXT: ret i1 [[CMP3]] ; CHECK-NEXT: ret i1 [[CMP3]]
; ;
%cmp = icmp sgt i32 %x, %y %cmp = icmp sgt i32 %x, %y
br i1 %cmp, label %same, label %different br i1 %cmp, label %same, label %different
same: same:
%cmp2 = icmp sle i32 %x, %y %cmp2 = icmp sle i32 %x, %y
ret i1 %cmp2 ret i1 %cmp2
different: different:
%cmp3 = icmp sgt i32 %x, %y %cmp3 = icmp sgt i32 %x, %y
ret i1 %cmp3 ret i1 %cmp3
} }
define i1 @test7_fp(float %x, float %y) { define i1 @test7_fp(float %x, float %y) {
; CHECK-LABEL: @test7_fp( ; CHECK-LABEL: @test7_fp(
; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]
; CHECK: [[X_0:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[X]]) ; CHECK: [[X_0:%.*]] = call float @llvm.ssa.copy.f32(float [[X]])
; CHECK: [[X_1:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[X]]) ; CHECK: [[X_1:%.*]] = call float @llvm.ssa.copy.f32(float [[X]])
; CHECK: [[Y_0:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[Y]]) ; CHECK: [[Y_0:%.*]] = call float @llvm.ssa.copy.f32(float [[Y]])
; CHECK: [[Y_1:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[Y]]) ; CHECK: [[Y_1:%.*]] = call float @llvm.ssa.copy.f32(float [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[SAME:%.*]], label [[DIFFERENT:%.*]]
; CHECK: same: ; CHECK: same:
; CHECK-NEXT: [[CMP2:%.*]] = fcmp ule float [[X_0]], [[Y_0]] ; CHECK-NEXT: [[CMP2:%.*]] = fcmp ule float [[X_0]], [[Y_0]]
; CHECK-NEXT: ret i1 [[CMP2]] ; CHECK-NEXT: ret i1 [[CMP2]]
; CHECK: different: ; CHECK: different:
; CHECK-NEXT: [[CMP3:%.*]] = fcmp ogt float [[X_1]], [[Y_1]] ; CHECK-NEXT: [[CMP3:%.*]] = fcmp ogt float [[X_1]], [[Y_1]]
; CHECK-NEXT: ret i1 [[CMP3]] ; CHECK-NEXT: ret i1 [[CMP3]]
; ;
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
different: different:
ret i1 %cmp3 ret i1 %cmp3
} }
define i32 @test9(i32 %i, i32 %j) { define i32 @test9(i32 %i, i32 %j) {
; CHECK-LABEL: @test9( ; CHECK-LABEL: @test9(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]]
; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[I]]) ; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[I]])
; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[J]]) ; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[J]])
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]]
; CHECK: cond_true: ; CHECK: cond_true:
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]] ; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]]
; CHECK-NEXT: ret i32 [[DIFF]] ; CHECK-NEXT: ret i32 [[DIFF]]
; CHECK: ret: ; CHECK: ret:
; CHECK-NEXT: ret i32 5 ; CHECK-NEXT: ret i32 5
; ;
%cmp = icmp eq i32 %i, %j %cmp = icmp eq i32 %i, %j
br i1 %cmp, label %cond_true, label %ret br i1 %cmp, label %cond_true, label %ret
cond_true: cond_true:
%diff = sub i32 %i, %j %diff = sub i32 %i, %j
ret i32 %diff ret i32 %diff
ret: ret:
ret i32 5 ret i32 5
} }
define i32 @test10(i32 %j, i32 %i) { define i32 @test10(i32 %j, i32 %i) {
; CHECK-LABEL: @test10( ; CHECK-LABEL: @test10(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[I:%.*]], [[J:%.*]]
; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[I]]) ; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[I]])
; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[J]]) ; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[J]])
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[RET:%.*]]
; CHECK: cond_true: ; CHECK: cond_true:
; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]] ; CHECK-NEXT: [[DIFF:%.*]] = sub i32 [[I_0]], [[J_0]]
; CHECK-NEXT: ret i32 [[DIFF]] ; CHECK-NEXT: ret i32 [[DIFF]]
; CHECK: ret: ; CHECK: ret:
; CHECK-NEXT: ret i32 5 ; CHECK-NEXT: ret i32 5
; ;
%cmp = icmp eq i32 %i, %j %cmp = icmp eq i32 %i, %j
Show All 9 Lines
declare i32 @yogibar() declare i32 @yogibar()
define i32 @test11(i32 %x) { define i32 @test11(i32 %x) {
; CHECK-LABEL: @test11( ; CHECK-LABEL: @test11(
; CHECK-NEXT: [[V0:%.*]] = call i32 @yogibar() ; CHECK-NEXT: [[V0:%.*]] = call i32 @yogibar()
; CHECK-NEXT: [[V1:%.*]] = call i32 @yogibar() ; CHECK-NEXT: [[V1:%.*]] = call i32 @yogibar()
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[V0]], [[V1]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[V0]], [[V1]]
; CHECK: [[V0_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[V0]]) ; CHECK: [[V0_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[V0]])
; CHECK: [[V1_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[V1]]) ; CHECK: [[V1_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[V1]])
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[NEXT:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[NEXT:%.*]]
; CHECK: cond_true: ; CHECK: cond_true:
; CHECK-NEXT: ret i32 [[V1_0]] ; CHECK-NEXT: ret i32 [[V1_0]]
; CHECK: next: ; CHECK: next:
; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X:%.*]], [[V0_0]] ; CHECK-NEXT: [[CMP2:%.*]] = icmp eq i32 [[X:%.*]], [[V0_0]]
; CHECK: [[V0_0_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[V0_0]]) ; CHECK: [[V0_0_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[V0_0]])
; CHECK-NEXT: br i1 [[CMP2]], label [[COND_TRUE2:%.*]], label [[NEXT2:%.*]] ; CHECK-NEXT: br i1 [[CMP2]], label [[COND_TRUE2:%.*]], label [[NEXT2:%.*]]
; CHECK: cond_true2: ; CHECK: cond_true2:
; CHECK-NEXT: ret i32 [[V0_0_1]] ; CHECK-NEXT: ret i32 [[V0_0_1]]
; CHECK: next2: ; CHECK: next2:
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
%v0 = call i32 @yogibar() %v0 = call i32 @yogibar()
%v1 = call i32 @yogibar() %v1 = call i32 @yogibar()
Show All 12 Lines
next2: next2:
ret i32 0 ret i32 0
} }
define i32 @test12(i32 %x) { define i32 @test12(i32 %x) {
; CHECK-LABEL: @test12( ; CHECK-LABEL: @test12(
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_FALSE:%.*]]
; CHECK: cond_true: ; CHECK: cond_true:
; CHECK-NEXT: br label [[RET:%.*]] ; CHECK-NEXT: br label [[RET:%.*]]
; CHECK: cond_false: ; CHECK: cond_false:
; CHECK-NEXT: br label [[RET]] ; CHECK-NEXT: br label [[RET]]
; CHECK: ret: ; CHECK: ret:
; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[X_0]], [[COND_TRUE]] ], [ [[X_1]], [[COND_FALSE]] ] ; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[X_0]], [[COND_TRUE]] ], [ [[X_1]], [[COND_FALSE]] ]
; CHECK-NEXT: ret i32 [[RES]] ; CHECK-NEXT: ret i32 [[RES]]
Show All 14 Lines

llvm/test/Transforms/Util/PredicateInfo/diamond.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -print-predicateinfo < %s 2>&1 | FileCheck %s ; RUN: opt -print-predicateinfo < %s 2>&1 | FileCheck %s
define i1 @f(i32 %x, i1 %y) { define i1 @f(i32 %x, i1 %y) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]] ; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]]
; CHECK: bb0: ; CHECK: bb0:
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB3:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB3:%.*]]
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1 ; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1
; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2 ; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2
; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X2]]) ; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X2]])
; CHECK-NEXT: br i1 [[CMP2]], label [[BB2]], label [[BB3]] ; CHECK-NEXT: br i1 [[CMP2]], label [[BB2]], label [[BB3]]
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ] ; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ]
; CHECK-NEXT: br label [[BB3]] ; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3: ; CHECK: bb3:
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
br i1 %y, label %bb0, label %bb1 br i1 %y, label %bb0, label %bb1
Show All 11 Lines;
ret i1 0 ret i1 0
} }
define i1 @g(i32 %x, i1 %y) { define i1 @g(i32 %x, i1 %y) {
; CHECK-LABEL: @g( ; CHECK-LABEL: @g(
; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]] ; CHECK-NEXT: br i1 [[Y:%.*]], label [[BB0:%.*]], label [[BB1:%.*]]
; CHECK: bb0: ; CHECK: bb0:
; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp sge i32 [[X:%.*]], 0
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[CMP]], label [[BB3:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[BB3:%.*]], label [[BB2:%.*]]
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1 ; CHECK-NEXT: [[X2:%.*]] = add nuw nsw i32 [[X]], 1
; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2 ; CHECK-NEXT: [[CMP2:%.*]] = icmp sge i32 [[X2]], 2
; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X2]]) ; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X2]])
; CHECK-NEXT: br i1 [[CMP2]], label [[BB3]], label [[BB2]] ; CHECK-NEXT: br i1 [[CMP2]], label [[BB3]], label [[BB2]]
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ] ; CHECK-NEXT: [[X3:%.*]] = phi i32 [ [[X_0]], [[BB0]] ], [ [[X2_0]], [[BB1]] ]
; CHECK-NEXT: br label [[BB3]] ; CHECK-NEXT: br label [[BB3]]
; CHECK: bb3: ; CHECK: bb3:
; CHECK-NEXT: ret i1 false ; CHECK-NEXT: ret i1 false
; ;
br i1 %y, label %bb0, label %bb1 br i1 %y, label %bb0, label %bb1
Show All 14 Lines

llvm/test/Transforms/Util/PredicateInfo/edge.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -print-predicateinfo < %s 2>&1 | FileCheck %s ; RUN: opt -print-predicateinfo < %s 2>&1 | FileCheck %s
define i32 @f1(i32 %x) { define i32 @f1(i32 %x) {
; CHECK-LABEL: @f1( ; CHECK-LABEL: @f1(
; CHECK-NEXT: bb0: ; CHECK-NEXT: bb0:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB1:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[BB2:%.*]], label [[BB1:%.*]]
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: br label [[BB2]] ; CHECK-NEXT: br label [[BB2]]
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]] ; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
; CHECK-NEXT: ret i32 [[FOO]] ; CHECK-NEXT: ret i32 [[FOO]]
; ;
bb0: bb0:
%cmp = icmp eq i32 %x, 0 %cmp = icmp eq i32 %x, 0
br i1 %cmp, label %bb2, label %bb1 br i1 %cmp, label %bb2, label %bb1
bb1: bb1:
br label %bb2 br label %bb2
bb2: bb2:
%cond = phi i32 [ %x, %bb0 ], [ 0, %bb1 ] %cond = phi i32 [ %x, %bb0 ], [ 0, %bb1 ]
%foo = add i32 %cond, %x %foo = add i32 %cond, %x
ret i32 %foo ret i32 %foo
} }
define i32 @f2(i32 %x) { define i32 @f2(i32 %x) {
; CHECK-LABEL: @f2( ; CHECK-LABEL: @f2(
; CHECK-NEXT: bb0: ; CHECK-NEXT: bb0:
; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0 ; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[X:%.*]], 0
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[CMP]], label [[BB1:%.*]], label [[BB2:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[BB1:%.*]], label [[BB2:%.*]]
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: br label [[BB2]] ; CHECK-NEXT: br label [[BB2]]
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]] ; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
; CHECK-NEXT: ret i32 [[FOO]] ; CHECK-NEXT: ret i32 [[FOO]]
; ;
bb0: bb0:
%cmp = icmp ne i32 %x, 0 %cmp = icmp ne i32 %x, 0
br i1 %cmp, label %bb1, label %bb2 br i1 %cmp, label %bb1, label %bb2
bb1: bb1:
br label %bb2 br label %bb2
bb2: bb2:
%cond = phi i32 [ %x, %bb0 ], [ 0, %bb1 ] %cond = phi i32 [ %x, %bb0 ], [ 0, %bb1 ]
%foo = add i32 %cond, %x %foo = add i32 %cond, %x
ret i32 %foo ret i32 %foo
} }
define i32 @f3(i32 %x) { define i32 @f3(i32 %x) {
; CHECK-LABEL: @f3( ; CHECK-LABEL: @f3(
; CHECK-NEXT: bb0: ; CHECK-NEXT: bb0:
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X:%.*]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X:%.*]])
; CHECK-NEXT: switch i32 [[X]], label [[BB1:%.*]] [ ; CHECK-NEXT: switch i32 [[X]], label [[BB1:%.*]] [
; CHECK-NEXT: i32 0, label [[BB2:%.*]] ; CHECK-NEXT: i32 0, label [[BB2:%.*]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: bb1: ; CHECK: bb1:
; CHECK-NEXT: br label [[BB2]] ; CHECK-NEXT: br label [[BB2]]
; CHECK: bb2: ; CHECK: bb2:
; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ] ; CHECK-NEXT: [[COND:%.*]] = phi i32 [ [[X_0]], [[BB0:%.*]] ], [ 0, [[BB1]] ]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]] ; CHECK-NEXT: [[FOO:%.*]] = add i32 [[COND]], [[X]]
Show All 9 Linesbb2:
ret i32 %foo ret i32 %foo
} }
define double @fcmp_oeq_not_zero(double %x, double %y) { define double @fcmp_oeq_not_zero(double %x, double %y) {
; CHECK-LABEL: @fcmp_oeq_not_zero( ; CHECK-LABEL: @fcmp_oeq_not_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 2.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 2.000000e+00
; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 10 Linesreturn:
ret double %retval ret double %retval
} }
define double @fcmp_une_not_zero(double %x, double %y) { define double @fcmp_une_not_zero(double %x, double %y) {
; CHECK-LABEL: @fcmp_une_not_zero( ; CHECK-LABEL: @fcmp_une_not_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], 2.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], 2.000000e+00
; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
; CHECK: else: ; CHECK: else:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 10 Linesreturn:
ret double %retval ret double %retval
} }
define double @fcmp_oeq_zero(double %x, double %y) { define double @fcmp_oeq_zero(double %x, double %y) {
; CHECK-LABEL: @fcmp_oeq_zero( ; CHECK-LABEL: @fcmp_oeq_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 0.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], 0.000000e+00
; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 10 Linesreturn:
ret double %retval ret double %retval
} }
define double @fcmp_une_zero(double %x, double %y) { define double @fcmp_une_zero(double %x, double %y) {
; CHECK-LABEL: @fcmp_une_zero( ; CHECK-LABEL: @fcmp_une_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], -0.000000e+00 ; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], -0.000000e+00
; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Y]])
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
; CHECK: else: ; CHECK: else:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Y_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 12 Lines
} }
define double @fcmp_oeq_maybe_zero(double %x, double %y, double %z1, double %z2) { define double @fcmp_oeq_maybe_zero(double %x, double %y, double %z1, double %z2) {
; CHECK-LABEL: @fcmp_oeq_maybe_zero( ; CHECK-LABEL: @fcmp_oeq_maybe_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]] ; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], [[Z]] ; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq double [[Y:%.*]], [[Z]]
; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Z]]) ; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Z]])
; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[IF:%.*]], label [[RETURN:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[IF]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 12 Lines
} }
define double @fcmp_une_maybe_zero(double %x, double %y, double %z1, double %z2) { define double @fcmp_une_maybe_zero(double %x, double %y, double %z1, double %z2) {
; CHECK-LABEL: @fcmp_une_maybe_zero( ; CHECK-LABEL: @fcmp_une_maybe_zero(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]] ; CHECK-NEXT: [[Z:%.*]] = fadd double [[Z1:%.*]], [[Z2:%.*]]
; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], [[Z]] ; CHECK-NEXT: [[CMP:%.*]] = fcmp une double [[Y:%.*]], [[Z]]
; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(double [[Z]]) ; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.f64(double [[Z]])
; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[RETURN:%.*]], label [[ELSE:%.*]]
; CHECK: else: ; CHECK: else:
; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]] ; CHECK-NEXT: [[DIV:%.*]] = fdiv double [[X:%.*]], [[Z_0]]
; CHECK-NEXT: br label [[RETURN]] ; CHECK-NEXT: br label [[RETURN]]
; CHECK: return: ; CHECK: return:
; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ] ; CHECK-NEXT: [[RETVAL:%.*]] = phi double [ [[DIV]], [[ELSE]] ], [ [[X]], [[ENTRY:%.*]] ]
; CHECK-NEXT: ret double [[RETVAL]] ; CHECK-NEXT: ret double [[RETVAL]]
; ;
Show All 14 Lines

llvm/test/Transforms/Util/PredicateInfo/testandor.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -print-predicateinfo -disable-output < %s 2>&1 | FileCheck %s
declare void @foo(i1) declare void @foo(i1)
declare void @bar(i32) declare void @bar(i32)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define void @test_or(i32 %x, i32 %y) { define void @test_or(i32 %x, i32 %y) {
; CHECK-LABEL: @test_or( ; CHECK-LABEL: @test_or(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]] ; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]]
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]]
; CHECK: oneof: ; CHECK: oneof:
; CHECK-NEXT: call void @foo(i1 [[XZ]]) ; CHECK-NEXT: call void @foo(i1 [[XZ]])
; CHECK-NEXT: call void @foo(i1 [[YZ]]) ; CHECK-NEXT: call void @foo(i1 [[YZ]])
; CHECK-NEXT: call void @bar(i32 [[X]]) ; CHECK-NEXT: call void @bar(i32 [[X]])
; CHECK-NEXT: call void @bar(i32 [[Y]]) ; CHECK-NEXT: call void @bar(i32 [[Y]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: neither: ; CHECK: neither:
Show All 24 Linesneither:
ret void ret void
} }
define void @test_or_logical(i32 %x, i32 %y) { define void @test_or_logical(i32 %x, i32 %y) {
; CHECK-LABEL: @test_or_logical( ; CHECK-LABEL: @test_or_logical(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 true, i1 [[YZ]] ; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 true, i1 [[YZ]]
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[ONEOF:%.*]], label [[NEITHER:%.*]]
; CHECK: oneof: ; CHECK: oneof:
; CHECK-NEXT: call void @foo(i1 [[XZ]]) ; CHECK-NEXT: call void @foo(i1 [[XZ]])
; CHECK-NEXT: call void @foo(i1 [[YZ]]) ; CHECK-NEXT: call void @foo(i1 [[YZ]])
; CHECK-NEXT: call void @bar(i32 [[X]]) ; CHECK-NEXT: call void @bar(i32 [[X]])
; CHECK-NEXT: call void @bar(i32 [[Y]]) ; CHECK-NEXT: call void @bar(i32 [[Y]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: neither: ; CHECK: neither:
Show All 24 Linesneither:
ret void ret void
} }
define void @test_and(i32 %x, i32 %y) { define void @test_and(i32 %x, i32 %y) {
; CHECK-LABEL: @test_and( ; CHECK-LABEL: @test_and(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]] ; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]]
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[XZ_0]]) ; CHECK-NEXT: call void @foo(i1 [[XZ_0]])
; CHECK-NEXT: call void @foo(i1 [[YZ_0]]) ; CHECK-NEXT: call void @foo(i1 [[YZ_0]])
; CHECK-NEXT: call void @bar(i32 [[X_0]]) ; CHECK-NEXT: call void @bar(i32 [[X_0]])
; CHECK-NEXT: call void @bar(i32 [[Y_0]]) ; CHECK-NEXT: call void @bar(i32 [[Y_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 24 Lines;; Should not insert on the false edge for and
ret void ret void
} }
define void @test_and_logical(i32 %x, i32 %y) { define void @test_and_logical(i32 %x, i32 %y) {
; CHECK-LABEL: @test_and_logical( ; CHECK-LABEL: @test_and_logical(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 [[YZ]], i1 false ; CHECK-NEXT: [[Z:%.*]] = select i1 [[XZ]], i1 [[YZ]], i1 false
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[XZ_0]]) ; CHECK-NEXT: call void @foo(i1 [[XZ_0]])
; CHECK-NEXT: call void @foo(i1 [[YZ_0]]) ; CHECK-NEXT: call void @foo(i1 [[YZ_0]])
; CHECK-NEXT: call void @bar(i32 [[X_0]]) ; CHECK-NEXT: call void @bar(i32 [[X_0]])
; CHECK-NEXT: call void @bar(i32 [[Y_0]]) ; CHECK-NEXT: call void @bar(i32 [[Y_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 24 Lines;; Should not insert on the false edge for and
ret void ret void
} }
define void @testandsame(i32 %x, i32 %y) { define void @testandsame(i32 %x, i32 %y) {
; CHECK-LABEL: @testandsame( ; CHECK-LABEL: @testandsame(
; CHECK-NEXT: [[XGT:%.*]] = icmp sgt i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XGT:%.*]] = icmp sgt i32 [[X:%.*]], 0
; CHECK-NEXT: [[XLT:%.*]] = icmp slt i32 [[X]], 100 ; CHECK-NEXT: [[XLT:%.*]] = icmp slt i32 [[X]], 100
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XGT]], [[XLT]] ; CHECK-NEXT: [[Z:%.*]] = and i1 [[XGT]], [[XLT]]
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[XGT_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XGT]]) ; CHECK: [[XGT_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XGT]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[X_0_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X_0]]) ; CHECK: [[X_0_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X_0]])
; CHECK: [[XLT_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XLT]]) ; CHECK: [[XLT_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XLT]])
; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[XGT_0]]) ; CHECK-NEXT: call void @foo(i1 [[XGT_0]])
; CHECK-NEXT: call void @foo(i1 [[XLT_0]]) ; CHECK-NEXT: call void @foo(i1 [[XLT_0]])
; CHECK-NEXT: call void @bar(i32 [[X_0_1]]) ; CHECK-NEXT: call void @bar(i32 [[X_0_1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
; CHECK-NEXT: call void @foo(i1 [[XGT]]) ; CHECK-NEXT: call void @foo(i1 [[XGT]])
Show All 18 Lines
} }
define void @testandassume(i32 %x, i32 %y) { define void @testandassume(i32 %x, i32 %y) {
; CHECK-LABEL: @testandassume( ; CHECK-LABEL: @testandassume(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]] ; CHECK-NEXT: [[Z:%.*]] = and i1 [[XZ]], [[YZ]]
; CHECK-NEXT: call void @llvm.assume(i1 [[Z]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[Z]])
; CHECK: [[TMP1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[TMP1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[TMP3:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[TMP3:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP5]]) ; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP5]])
; CHECK: [[DOT01:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP4]]) ; CHECK: [[DOT01:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP4]])
; CHECK: [[DOT02:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP3]]) ; CHECK: [[DOT02:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP3]])
; CHECK: [[DOT03:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP2]]) ; CHECK: [[DOT03:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP2]])
; CHECK: [[DOT04:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP1]]) ; CHECK: [[DOT04:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP1]])
; CHECK-NEXT: br i1 [[TMP5]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[TMP5]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[DOT01]]) ; CHECK-NEXT: call void @foo(i1 [[DOT01]])
; CHECK-NEXT: call void @foo(i1 [[DOT03]]) ; CHECK-NEXT: call void @foo(i1 [[DOT03]])
; CHECK-NEXT: call void @bar(i32 [[DOT02]]) ; CHECK-NEXT: call void @bar(i32 [[DOT02]])
; CHECK-NEXT: call void @bar(i32 [[DOT04]]) ; CHECK-NEXT: call void @bar(i32 [[DOT04]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 19 Lines
;; Unlike and/or for branches, assume is *always* true, so we only match and for it ;; Unlike and/or for branches, assume is *always* true, so we only match and for it
define void @testorassume(i32 %x, i32 %y) { define void @testorassume(i32 %x, i32 %y) {
; ;
; CHECK-LABEL: @testorassume( ; CHECK-LABEL: @testorassume(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0 ; CHECK-NEXT: [[YZ:%.*]] = icmp eq i32 [[Y:%.*]], 0
; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]] ; CHECK-NEXT: [[Z:%.*]] = or i1 [[XZ]], [[YZ]]
; CHECK-NEXT: call void @llvm.assume(i1 [[Z]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[Z]])
; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP1]]) ; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP1]])
; CHECK-NEXT: br i1 [[TMP1]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[TMP1]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[XZ]]) ; CHECK-NEXT: call void @foo(i1 [[XZ]])
; CHECK-NEXT: call void @foo(i1 [[YZ]]) ; CHECK-NEXT: call void @foo(i1 [[YZ]])
; CHECK-NEXT: call void @bar(i32 [[X]]) ; CHECK-NEXT: call void @bar(i32 [[X]])
; CHECK-NEXT: call void @bar(i32 [[Y]]) ; CHECK-NEXT: call void @bar(i32 [[Y]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 15 Linesnope:
call void @foo(i1 %z) call void @foo(i1 %z)
ret void ret void
} }
define void @test_and_one_unknown_cond(i32 %x, i1 %c1) { define void @test_and_one_unknown_cond(i32 %x, i1 %c1) {
; CHECK-LABEL: @test_and_one_unknown_cond( ; CHECK-LABEL: @test_and_one_unknown_cond(
; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[A:%.*]] = and i1 [[C1:%.*]], [[C2]] ; CHECK-NEXT: [[A:%.*]] = and i1 [[C1:%.*]], [[C2]]
; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[A_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[C1_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C1]]) ; CHECK: [[C1_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C1]])
; CHECK: [[C2_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C2]]) ; CHECK: [[C2_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C2]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[A]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[A]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @bar(i32 [[X_0]]) ; CHECK-NEXT: call void @bar(i32 [[X_0]])
; CHECK-NEXT: call void @foo(i1 [[C1_0]]) ; CHECK-NEXT: call void @foo(i1 [[C1_0]])
; CHECK-NEXT: call void @foo(i1 [[C2_0]]) ; CHECK-NEXT: call void @foo(i1 [[C2_0]])
; CHECK-NEXT: call void @foo(i1 [[A_0]]) ; CHECK-NEXT: call void @foo(i1 [[A_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 21 Linesnope:
call void @foo(i1 %a) call void @foo(i1 %a)
ret void ret void
} }
define void @test_or_one_unknown_cond(i32 %x, i1 %c1) { define void @test_or_one_unknown_cond(i32 %x, i1 %c1) {
; CHECK-LABEL: @test_or_one_unknown_cond( ; CHECK-LABEL: @test_or_one_unknown_cond(
; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[C2:%.*]] = icmp eq i32 [[X:%.*]], 0
; CHECK-NEXT: [[A:%.*]] = or i1 [[C1:%.*]], [[C2]] ; CHECK-NEXT: [[A:%.*]] = or i1 [[C1:%.*]], [[C2]]
; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[A_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[C1_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C1]]) ; CHECK: [[C1_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C1]])
; CHECK: [[C2_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C2]]) ; CHECK: [[C2_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C2]])
; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK-NEXT: br i1 [[A]], label [[NOPE:%.*]], label [[BOTH_INVERTED:%.*]] ; CHECK-NEXT: br i1 [[A]], label [[NOPE:%.*]], label [[BOTH_INVERTED:%.*]]
; CHECK: both_inverted: ; CHECK: both_inverted:
; CHECK-NEXT: call void @bar(i32 [[X_0]]) ; CHECK-NEXT: call void @bar(i32 [[X_0]])
; CHECK-NEXT: call void @foo(i1 [[C1_0]]) ; CHECK-NEXT: call void @foo(i1 [[C1_0]])
; CHECK-NEXT: call void @foo(i1 [[C2_0]]) ; CHECK-NEXT: call void @foo(i1 [[C2_0]])
; CHECK-NEXT: call void @foo(i1 [[A_1]]) ; CHECK-NEXT: call void @foo(i1 [[A_1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
Show All 21 Linesnope:
call void @foo(i1 %a) call void @foo(i1 %a)
ret void ret void
} }
define void @test_and_chain(i1 %a, i1 %b, i1 %c) { define void @test_and_chain(i1 %a, i1 %b, i1 %c) {
; CHECK-LABEL: @test_and_chain( ; CHECK-LABEL: @test_and_chain(
; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]] ; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]]
; CHECK: [[AND2_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND2]]) ; CHECK: [[AND2_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND2]])
; CHECK: [[AND2_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND2]]) ; CHECK: [[AND2_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND2]])
; CHECK: [[AND1_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND1]]) ; CHECK: [[AND1_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND1]])
; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[B_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[B]]) ; CHECK: [[B_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[B]])
; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C]]) ; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C]])
; CHECK-NEXT: br i1 [[AND2]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[AND2]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A_0]]) ; CHECK-NEXT: call void @foo(i1 [[A_0]])
; CHECK-NEXT: call void @foo(i1 [[B_0]]) ; CHECK-NEXT: call void @foo(i1 [[B_0]])
; CHECK-NEXT: call void @foo(i1 [[C_0]]) ; CHECK-NEXT: call void @foo(i1 [[C_0]])
; CHECK-NEXT: call void @foo(i1 [[AND1_0]]) ; CHECK-NEXT: call void @foo(i1 [[AND1_0]])
; CHECK-NEXT: call void @foo(i1 [[AND2_0]]) ; CHECK-NEXT: call void @foo(i1 [[AND2_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 25 Lineselse:
call void @foo(i1 %and2) call void @foo(i1 %and2)
ret void ret void
} }
define void @test_or_chain(i1 %a, i1 %b, i1 %c) { define void @test_or_chain(i1 %a, i1 %b, i1 %c) {
; CHECK-LABEL: @test_or_chain( ; CHECK-LABEL: @test_or_chain(
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]] ; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]]
; CHECK: [[OR2_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[OR2]]) ; CHECK: [[OR2_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[OR2]])
; CHECK: [[OR2_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[OR2]]) ; CHECK: [[OR2_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[OR2]])
; CHECK: [[OR1_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[OR1]]) ; CHECK: [[OR1_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[OR1]])
; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[A_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[B_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[B]]) ; CHECK: [[B_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[B]])
; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C]]) ; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C]])
; CHECK-NEXT: br i1 [[OR2]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[OR2]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A]]) ; CHECK-NEXT: call void @foo(i1 [[A]])
; CHECK-NEXT: call void @foo(i1 [[B]]) ; CHECK-NEXT: call void @foo(i1 [[B]])
; CHECK-NEXT: call void @foo(i1 [[C]]) ; CHECK-NEXT: call void @foo(i1 [[C]])
; CHECK-NEXT: call void @foo(i1 [[OR1]]) ; CHECK-NEXT: call void @foo(i1 [[OR1]])
; CHECK-NEXT: call void @foo(i1 [[OR2_0]]) ; CHECK-NEXT: call void @foo(i1 [[OR2_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 25 Lineselse:
call void @foo(i1 %or2) call void @foo(i1 %or2)
ret void ret void
} }
define void @test_and_or_mixed(i1 %a, i1 %b, i1 %c) { define void @test_and_or_mixed(i1 %a, i1 %b, i1 %c) {
; CHECK-LABEL: @test_and_or_mixed( ; CHECK-LABEL: @test_and_or_mixed(
; CHECK-NEXT: [[OR:%.*]] = or i1 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[OR:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[AND:%.*]] = and i1 [[OR]], [[C:%.*]] ; CHECK-NEXT: [[AND:%.*]] = and i1 [[OR]], [[C:%.*]]
; CHECK: [[AND_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND]]) ; CHECK: [[AND_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND]])
; CHECK: [[AND_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND]]) ; CHECK: [[AND_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND]])
; CHECK: [[OR_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[OR]]) ; CHECK: [[OR_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[OR]])
; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C]]) ; CHECK: [[C_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C]])
; CHECK-NEXT: br i1 [[AND]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[AND]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A]]) ; CHECK-NEXT: call void @foo(i1 [[A]])
; CHECK-NEXT: call void @foo(i1 [[B]]) ; CHECK-NEXT: call void @foo(i1 [[B]])
; CHECK-NEXT: call void @foo(i1 [[C_0]]) ; CHECK-NEXT: call void @foo(i1 [[C_0]])
; CHECK-NEXT: call void @foo(i1 [[OR_0]]) ; CHECK-NEXT: call void @foo(i1 [[OR_0]])
; CHECK-NEXT: call void @foo(i1 [[AND_0]]) ; CHECK-NEXT: call void @foo(i1 [[AND_0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 37 Lines
; CHECK-NEXT: [[A8:%.*]] = and i1 [[A7]], true ; CHECK-NEXT: [[A8:%.*]] = and i1 [[A7]], true
; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], true ; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], true
; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], true ; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], true
; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], true ; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], true
; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], true ; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], true
; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], true ; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], true
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], true ; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], true
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], true ; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], true
; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A14]]) ; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A14]])
; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A13]]) ; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A13]])
; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A12]]) ; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A12]])
; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A11]]) ; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A11]])
; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A10]]) ; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A10]])
; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A9]]) ; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A9]])
; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A8]]) ; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A8]])
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A1]]) ; CHECK-NEXT: call void @foo(i1 [[A1]])
; CHECK-NEXT: call void @foo(i1 [[A2]]) ; CHECK-NEXT: call void @foo(i1 [[A2]])
; CHECK-NEXT: call void @foo(i1 [[A3]]) ; CHECK-NEXT: call void @foo(i1 [[A3]])
; CHECK-NEXT: call void @foo(i1 [[A4]]) ; CHECK-NEXT: call void @foo(i1 [[A4]])
; CHECK-NEXT: call void @foo(i1 [[A5]]) ; CHECK-NEXT: call void @foo(i1 [[A5]])
; CHECK-NEXT: call void @foo(i1 [[A6]]) ; CHECK-NEXT: call void @foo(i1 [[A6]])
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[A8:%.*]] = and i1 [[A7]], [[A7]] ; CHECK-NEXT: [[A8:%.*]] = and i1 [[A7]], [[A7]]
; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], [[A8]] ; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], [[A8]]
; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], [[A9]] ; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], [[A9]]
; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], [[A10]] ; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], [[A10]]
; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], [[A11]] ; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], [[A11]]
; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], [[A12]] ; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], [[A12]]
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]] ; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]]
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]] ; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]]
; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A14]]) ; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A14]])
; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A13]]) ; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A13]])
; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A12]]) ; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A12]])
; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A11]]) ; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A11]])
; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A10]]) ; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A10]])
; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A9]]) ; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A9]])
; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A8]]) ; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A8]])
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A1]]) ; CHECK-NEXT: call void @foo(i1 [[A1]])
; CHECK-NEXT: call void @foo(i1 [[A2]]) ; CHECK-NEXT: call void @foo(i1 [[A2]])
; CHECK-NEXT: call void @foo(i1 [[A3]]) ; CHECK-NEXT: call void @foo(i1 [[A3]])
; CHECK-NEXT: call void @foo(i1 [[A4]]) ; CHECK-NEXT: call void @foo(i1 [[A4]])
; CHECK-NEXT: call void @foo(i1 [[A5]]) ; CHECK-NEXT: call void @foo(i1 [[A5]])
; CHECK-NEXT: call void @foo(i1 [[A6]]) ; CHECK-NEXT: call void @foo(i1 [[A6]])
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[A8:%.*]] = or i1 [[A7]], [[A7]] ; CHECK-NEXT: [[A8:%.*]] = or i1 [[A7]], [[A7]]
; CHECK-NEXT: [[A9:%.*]] = or i1 [[A8]], [[A8]] ; CHECK-NEXT: [[A9:%.*]] = or i1 [[A8]], [[A8]]
; CHECK-NEXT: [[A10:%.*]] = or i1 [[A9]], [[A9]] ; CHECK-NEXT: [[A10:%.*]] = or i1 [[A9]], [[A9]]
; CHECK-NEXT: [[A11:%.*]] = or i1 [[A10]], [[A10]] ; CHECK-NEXT: [[A11:%.*]] = or i1 [[A10]], [[A10]]
; CHECK-NEXT: [[A12:%.*]] = or i1 [[A11]], [[A11]] ; CHECK-NEXT: [[A12:%.*]] = or i1 [[A11]], [[A11]]
; CHECK-NEXT: [[A13:%.*]] = or i1 [[A12]], [[A12]] ; CHECK-NEXT: [[A13:%.*]] = or i1 [[A12]], [[A12]]
; CHECK-NEXT: [[A14:%.*]] = or i1 [[A13]], [[A13]] ; CHECK-NEXT: [[A14:%.*]] = or i1 [[A13]], [[A13]]
; CHECK-NEXT: [[A15:%.*]] = or i1 [[A14]], [[A14]] ; CHECK-NEXT: [[A15:%.*]] = or i1 [[A14]], [[A14]]
; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[A15_1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A14]]) ; CHECK: [[A14_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A14]])
; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A13]]) ; CHECK: [[A13_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A13]])
; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A12]]) ; CHECK: [[A12_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A12]])
; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A11]]) ; CHECK: [[A11_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A11]])
; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A10]]) ; CHECK: [[A10_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A10]])
; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A9]]) ; CHECK: [[A9_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A9]])
; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A8]]) ; CHECK: [[A8_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A8]])
; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]] ; CHECK-NEXT: br i1 [[A15]], label [[IF:%.*]], label [[ELSE:%.*]]
; CHECK: if: ; CHECK: if:
; CHECK-NEXT: call void @foo(i1 [[A1]]) ; CHECK-NEXT: call void @foo(i1 [[A1]])
; CHECK-NEXT: call void @foo(i1 [[A2]]) ; CHECK-NEXT: call void @foo(i1 [[A2]])
; CHECK-NEXT: call void @foo(i1 [[A3]]) ; CHECK-NEXT: call void @foo(i1 [[A3]])
; CHECK-NEXT: call void @foo(i1 [[A4]]) ; CHECK-NEXT: call void @foo(i1 [[A4]])
; CHECK-NEXT: call void @foo(i1 [[A5]]) ; CHECK-NEXT: call void @foo(i1 [[A5]])
; CHECK-NEXT: call void @foo(i1 [[A6]]) ; CHECK-NEXT: call void @foo(i1 [[A6]])
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lineselse:
ret void ret void
} }
define void @test_assume_and_chain(i1 %a, i1 %b, i1 %c) { define void @test_assume_and_chain(i1 %a, i1 %b, i1 %c) {
; CHECK-LABEL: @test_assume_and_chain( ; CHECK-LABEL: @test_assume_and_chain(
; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[AND1:%.*]] = and i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]] ; CHECK-NEXT: [[AND2:%.*]] = and i1 [[AND1]], [[C:%.*]]
; CHECK-NEXT: call void @llvm.assume(i1 [[AND2]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[AND2]])
; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[C]]) ; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[C]])
; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[B]]) ; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[B]])
; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A]]) ; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A]])
; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND1]]) ; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND1]])
; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[AND2]]) ; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[AND2]])
; CHECK-NEXT: call void @foo(i1 [[TMP3]]) ; CHECK-NEXT: call void @foo(i1 [[TMP3]])
; CHECK-NEXT: call void @foo(i1 [[TMP2]]) ; CHECK-NEXT: call void @foo(i1 [[TMP2]])
; CHECK-NEXT: call void @foo(i1 [[TMP1]]) ; CHECK-NEXT: call void @foo(i1 [[TMP1]])
; CHECK-NEXT: call void @foo(i1 [[TMP4]]) ; CHECK-NEXT: call void @foo(i1 [[TMP4]])
; CHECK-NEXT: call void @foo(i1 [[TMP5]]) ; CHECK-NEXT: call void @foo(i1 [[TMP5]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%and1 = and i1 %a, %b %and1 = and i1 %a, %b
%and2 = and i1 %and1, %c %and2 = and i1 %and1, %c
call void @llvm.assume(i1 %and2) call void @llvm.assume(i1 %and2)
call void @foo(i1 %a) call void @foo(i1 %a)
call void @foo(i1 %b) call void @foo(i1 %b)
call void @foo(i1 %c) call void @foo(i1 %c)
call void @foo(i1 %and1) call void @foo(i1 %and1)
call void @foo(i1 %and2) call void @foo(i1 %and2)
ret void ret void
} }
define void @test_assume_or_chain(i1 %a, i1 %b, i1 %c) { define void @test_assume_or_chain(i1 %a, i1 %b, i1 %c) {
; CHECK-LABEL: @test_assume_or_chain( ; CHECK-LABEL: @test_assume_or_chain(
; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[OR1:%.*]] = or i1 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]] ; CHECK-NEXT: [[OR2:%.*]] = or i1 [[OR1]], [[C:%.*]]
; CHECK-NEXT: call void @llvm.assume(i1 [[OR2]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[OR2]])
; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[OR2]]) ; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[OR2]])
; CHECK-NEXT: call void @foo(i1 [[A]]) ; CHECK-NEXT: call void @foo(i1 [[A]])
; CHECK-NEXT: call void @foo(i1 [[B]]) ; CHECK-NEXT: call void @foo(i1 [[B]])
; CHECK-NEXT: call void @foo(i1 [[C]]) ; CHECK-NEXT: call void @foo(i1 [[C]])
; CHECK-NEXT: call void @foo(i1 [[OR1]]) ; CHECK-NEXT: call void @foo(i1 [[OR1]])
; CHECK-NEXT: call void @foo(i1 [[TMP1]]) ; CHECK-NEXT: call void @foo(i1 [[TMP1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%or1 = or i1 %a, %b %or1 = or i1 %a, %b
Show All 19 Lines
; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], [[A8]] ; CHECK-NEXT: [[A9:%.*]] = and i1 [[A8]], [[A8]]
; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], [[A9]] ; CHECK-NEXT: [[A10:%.*]] = and i1 [[A9]], [[A9]]
; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], [[A10]] ; CHECK-NEXT: [[A11:%.*]] = and i1 [[A10]], [[A10]]
; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], [[A11]] ; CHECK-NEXT: [[A12:%.*]] = and i1 [[A11]], [[A11]]
; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], [[A12]] ; CHECK-NEXT: [[A13:%.*]] = and i1 [[A12]], [[A12]]
; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]] ; CHECK-NEXT: [[A14:%.*]] = and i1 [[A13]], [[A13]]
; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]] ; CHECK-NEXT: [[A15:%.*]] = and i1 [[A14]], [[A14]]
; CHECK-NEXT: call void @llvm.assume(i1 [[A15]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[A15]])
; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A8]]) ; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A8]])
; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A9]]) ; CHECK: [[TMP2:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A9]])
; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A10]]) ; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A10]])
; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A11]]) ; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A11]])
; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A12]]) ; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A12]])
; CHECK: [[TMP6:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A13]]) ; CHECK: [[TMP6:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A13]])
; CHECK: [[TMP7:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A14]]) ; CHECK: [[TMP7:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A14]])
; CHECK: [[TMP8:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[A15]]) ; CHECK: [[TMP8:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[A15]])
; CHECK-NEXT: call void @foo(i1 [[A1]]) ; CHECK-NEXT: call void @foo(i1 [[A1]])
; CHECK-NEXT: call void @foo(i1 [[A2]]) ; CHECK-NEXT: call void @foo(i1 [[A2]])
; CHECK-NEXT: call void @foo(i1 [[A3]]) ; CHECK-NEXT: call void @foo(i1 [[A3]])
; CHECK-NEXT: call void @foo(i1 [[A4]]) ; CHECK-NEXT: call void @foo(i1 [[A4]])
; CHECK-NEXT: call void @foo(i1 [[A5]]) ; CHECK-NEXT: call void @foo(i1 [[A5]])
; CHECK-NEXT: call void @foo(i1 [[A6]]) ; CHECK-NEXT: call void @foo(i1 [[A6]])
; CHECK-NEXT: call void @foo(i1 [[A7]]) ; CHECK-NEXT: call void @foo(i1 [[A7]])
; CHECK-NEXT: call void @foo(i1 [[TMP1]]) ; CHECK-NEXT: call void @foo(i1 [[TMP1]])
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Transforms/Util/PredicateInfo/unnamed-types.ll

; RUN: opt < %s -print-predicateinfo 2>&1 | FileCheck %s ; RUN: opt < %s -print-predicateinfo 2>&1 | FileCheck %s
%1 = type opaque %1 = type opaque
%0 = type opaque %0 = type opaque
; Check we can use ssa.copy with unnamed types. ; Check we can use ssa.copy with unnamed types.
; CHECK-LABEL: bb: ; CHECK-LABEL: bb:
; CHECK: Has predicate info ; CHECK: Has predicate info
; CHECK: branch predicate info { TrueEdge: 1 Comparison: %cmp1 = icmp ne %0* %arg, null Edge: [label %bb,label %bb1], RenamedOp: %arg } ; CHECK: branch predicate info { TrueEdge: 1 Comparison: %cmp1 = icmp ne %0* %arg, null Edge: [label %bb,label %bb1], RenamedOp: %arg }
; CHECK-NEXT: %arg.0 = call %0* @llvm.ssa.copy.{{.+}}(%0* %arg) ; CHECK-NEXT: %arg.0 = call %0* @llvm.ssa.copy.p0s_s.{{.+}}(%0* %arg)
; CHECK-LABEL: bb1: ; CHECK-LABEL: bb1:
; CHECK: Has predicate info ; CHECK: Has predicate info
; CHECK-NEXT: branch predicate info { TrueEdge: 0 Comparison: %cmp2 = icmp ne %1* null, %tmp Edge: [label %bb1,label %bb3], RenamedOp: %tmp } ; CHECK-NEXT: branch predicate info { TrueEdge: 0 Comparison: %cmp2 = icmp ne %1* null, %tmp Edge: [label %bb1,label %bb3], RenamedOp: %tmp }
; CHECK-NEXT: %tmp.0 = call %1* @llvm.ssa.copy.{{.+}}(%1* %tmp) ; CHECK-NEXT: %tmp.0 = call %1* @llvm.ssa.copy.p0s_s.{{.+}}(%1* %tmp)
define void @f0(%0* %arg, %1* %tmp) { define void @f0(%0* %arg, %1* %tmp) {
bb: bb:
%cmp1 = icmp ne %0* %arg, null %cmp1 = icmp ne %0* %arg, null
br i1 %cmp1, label %bb1, label %bb2 br i1 %cmp1, label %bb1, label %bb2
bb1: ; preds = %bb bb1: ; preds = %bb
%cmp2 = icmp ne %1* null, %tmp %cmp2 = icmp ne %1* null, %tmp
Show All 12 Lines