This is an archive of the discontinued LLVM Phabricator instance.

Differential D91661

Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with unnamed types.
ClosedPublic

Authored by jeroen.dobbelaere on Nov 17 2020, 2:28 PM.

Details

Reviewers
fhahn
efriedma
nikic
Commits
rG77080a1eb606: Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with…
Summary

Now that intrinsic name mangling can cope with unnamed types, the custom name mangling in PredicateInfo (introduced by D49126) can be removed.
(See D91250, D48541)

Diff Detail

Event Timeline

jeroen.dobbelaere created this revision.Nov 17 2020, 2:28 PM
Herald added a project: Restricted Project. · View Herald TranscriptNov 17 2020, 2:28 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
jeroen.dobbelaere requested review of this revision.Nov 17 2020, 2:28 PM
jeroen.dobbelaere added a parent revision: D91250: Support intrinsic overloading on unnamed types.
jeroen.dobbelaere edited the summary of this revision. (Show Details)Nov 17 2020, 2:35 PM
jeroen.dobbelaere updated this revision to Diff 306447.Nov 19 2020, 10:01 AM

Omitted reversal of NewGVN testcase that slipped in with the original (D49126) commit. It has nothing to do with the unnamed type support.

jeroen.dobbelaere updated this revision to Diff 329311.Mar 9 2021, 5:58 AM
  • rebased
Harbormaster completed remote builds in B92862: Diff 329311.Mar 9 2021, 2:43 PM
fhahn added inline comments.Mar 10 2021, 12:19 PM
llvm/test/Transforms/Util/PredicateInfo/testandor.ll
139

do you know why the order changed here?

212

no need to have {{.+}} here any longer?

jeroen.dobbelaere added inline comments.Mar 10 2021, 1:28 PM
llvm/test/Transforms/Util/PredicateInfo/testandor.ll
139

Good that you asked. The reverted code now also reverses some of the insertions. Working on a fix.

jeroen.dobbelaere updated this revision to Diff 329773.Mar 10 2021, 2:22 PM

Fixed an unwanted reversal of instructions shown in the testandor.ll test.

jeroen.dobbelaere marked 2 inline comments as done.Mar 10 2021, 2:23 PM
Harbormaster completed remote builds in B93168: Diff 329773.Mar 11 2021, 1:46 AM
fhahn accepted this revision.Mar 14 2021, 3:08 PM

LGTM, thanks!

llvm/lib/Transforms/Utils/PredicateInfo.cpp
787

nit: move to the header?

This revision is now accepted and ready to land.Mar 14 2021, 3:08 PM
jeroen.dobbelaere updated this revision to Diff 331852.Mar 19 2021, 6:32 AM

Rebased. Moved ~PredicateInfo() to header.

Harbormaster completed remote builds in B94689: Diff 331852.Mar 19 2021, 7:47 AM
Closed by commit rG77080a1eb606: Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with… (authored by jeroen.dobbelaere). · Explain WhyMar 20 2021, 3:39 AM
This revision was automatically updated to reflect the committed changes.
jeroen.dobbelaere added a commit: rG77080a1eb606: Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with….
jroelofs added a subscriber: jroelofs.Jul 13 2021, 12:44 PM

This patch is causing issues with the EXPENSIVE_CHECKS build, which detects that the pass modified the IR without reporting it has done so via runOnFunction's return value. Would you mind taking a look?

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

Pass modifies its input and doesn't report it: PredicateInfo Printer
Pass modifies its input and doesn't report it
UNREACHABLE executed at llvm/lib/IR/LegacyPassManager.cpp:1445!
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
Herald added a subscriber: ormris. · View Herald TranscriptJul 13 2021, 12:44 PM
jeroen.dobbelaere added a comment.Jul 13 2021, 12:51 PM
In D91661#2875179, @jroelofs wrote:

This patch is causing issues with the EXPENSIVE_CHECKS build, which detects that the pass modified the IR without reporting it has done so via runOnFunction's return value. Would you mind taking a look?

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

Pass modifies its input and doesn't report it: PredicateInfo Printer
Pass modifies its input and doesn't report it
UNREACHABLE executed at llvm/lib/IR/LegacyPassManager.cpp:1445!
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:

Thanks for the notificiation. I'll take a look at it.

jeroen.dobbelaere added a comment.Jul 14 2021, 3:43 AM

@jroelofs I tried to run llvm/test/Transforms/Util/PredicateInfo/testandor.ll for both rG77080a1eb6061df2dcfae8ac84b85ad4d1e02031 (the moment of the commit) and rGfb9c5c3dce27b352534641dbb6e3cb8c05da7bc9 (recent main), with -DLLVM_ENABLE_EXPENSIVE_CHECKS=1.
I checked that the -DEXPENSIVE_CHECKS is added to the ninja.build file. But, I am not able to observe the issue you are mentioning. How can I reproduce this problem ?

fhahn added a comment.Jul 14 2021, 4:32 AM
In D91661#2876667, @jeroen.dobbelaere wrote:

@jroelofs I tried to run llvm/test/Transforms/Util/PredicateInfo/testandor.ll for both rG77080a1eb6061df2dcfae8ac84b85ad4d1e02031 (the moment of the commit) and rGfb9c5c3dce27b352534641dbb6e3cb8c05da7bc9 (recent main), with -DLLVM_ENABLE_EXPENSIVE_CHECKS=1.
I checked that the -DEXPENSIVE_CHECKS is added to the ninja.build file. But, I am not able to observe the issue you are mentioning. How can I reproduce this problem ?

Are you using the legacy pass manager? From the message Jon shared, it looks like it comes from the legacy PM.

jeroen.dobbelaere added a subscriber: • dberlin.Jul 14 2021, 4:49 AM
In D91661#2876696, @fhahn wrote:

Are you using the legacy pass manager? From the message Jon shared, it looks like it comes from the legacy PM.

That did the trick. @dberlin Created this pass, but I am not sure he is still active. Although this pass is used to dump information, it does seem to introduce llvm.ssa.copy calls. I'll see how to modify the return value so that it correctly identifies changes.

jeroen.dobbelaere mentioned this in D105983: [PredicateInfo] return true when the function was modified.Jul 14 2021, 7:37 AM
jeroen.dobbelaere mentioned this in D106147: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types..Jul 16 2021, 6:26 AM
jeroen.dobbelaere added a reverting change: rGdc5570d149ca: Revert "Revert of D49126 [PredicateInfo] Use custom mangling to support….Jul 28 2021, 10:31 AM
jeroen.dobbelaere mentioned this in rG03b8c69d06f8: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types..

Revision Contents

PathSize
llvm/
include/
llvm/
Transforms/
Utils/
4 lines
lib/
Transforms/
Utils/
65 lines
test/
Other/
4 lines
Transforms/
NewGVN/
2 lines
Util/
PredicateInfo/
54 lines
8 lines
18 lines
56 lines
4 lines

Diff 305906

llvm/include/llvm/Transforms/Utils/PredicateInfo.h

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
/// ///
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H #ifndef LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H
#define LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H #define LLVM_TRANSFORMS_UTILS_PREDICATEINFO_H
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/ilist.h" #include "llvm/ADT/ilist.h"
#include "llvm/ADT/ilist_node.h" #include "llvm/ADT/ilist_node.h"
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/PassManager.h" #include "llvm/IR/PassManager.h"
#include "llvm/IR/Value.h" #include "llvm/IR/Value.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
namespace llvm { namespace llvm {
class AssumptionCache; class AssumptionCache;
class DominatorTree; class DominatorTree;
class Function; class Function;
class IntrinsicInst; class IntrinsicInst;
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Linesprivate:
// This owns the all the predicate infos in the function, placed or not. // This owns the all the predicate infos in the function, placed or not.
iplist<PredicateBase> AllInfos; iplist<PredicateBase> AllInfos;
// This maps from copy operands to Predicate Info. Note that it does not own // This maps from copy operands to Predicate Info. Note that it does not own
// the Predicate Info, they belong to the ValueInfo structs in the ValueInfos // the Predicate Info, they belong to the ValueInfo structs in the ValueInfos
// vector. // vector.
DenseMap<const Value *, const PredicateBase *> PredicateMap; DenseMap<const Value *, const PredicateBase *> PredicateMap;
// The set of ssa_copy declarations we created with our custom mangling.
SmallSet<AssertingVH<Function>, 20> CreatedDeclarations;
}; };
// This pass does eager building and then printing of PredicateInfo. It is used // This pass does eager building and then printing of PredicateInfo. It is used
// by // by
// the tests to be able to build, dump, and verify PredicateInfo. // the tests to be able to build, dump, and verify PredicateInfo.
class PredicateInfoPrinterLegacyPass : public FunctionPass { class PredicateInfoPrinterLegacyPass : public FunctionPass {
public: public:
PredicateInfoPrinterLegacyPass(); PredicateInfoPrinterLegacyPass();
Show All 24 Lines

llvm/lib/Transforms/Utils/PredicateInfo.cpp

Show All 10 Lines
//===----------------------------------------------------------------===// //===----------------------------------------------------------------===//
#include "llvm/Transforms/Utils/PredicateInfo.h" #include "llvm/Transforms/Utils/PredicateInfo.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Analysis/AssumptionCache.h" #include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/CFG.h" #include "llvm/Analysis/CFG.h"
#include "llvm/IR/AssemblyAnnotationWriter.h" #include "llvm/IR/AssemblyAnnotationWriter.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/GlobalVariable.h" #include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h" #include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/PatternMatch.h" #include "llvm/IR/PatternMatch.h"
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
▲ Show 20 Lines • Show All 523 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 15 Lines ValInfo->RenamedOp = (RenameStack.end() - Start) == RenameStack.begin()
: (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.
if (isa<PredicateWithEdge>(ValInfo)) { if (isa<PredicateWithEdge>(ValInfo)) {
IRBuilder<> B(getBranchTerminator(ValInfo)); IRBuilder<> B(getBranchTerminator(ValInfo));
Function *IF = getCopyDeclaration(F.getParent(), Op->getType()); Function *IF = Intrinsic::getDeclaration(
if (IF->users().empty()) F.getParent(), Intrinsic::ssa_copy, Op->getType());
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 IRBuilder<> B(PAssume->AssumeInst);
// directly before it, assume(i1 true) is not a useful fact. Function *IF = Intrinsic::getDeclaration(
IRBuilder<> B(PAssume->AssumeInst->getNextNode()); F.getParent(), Intrinsic::ssa_copy, Op->getType());
Function *IF = getCopyDeclaration(F.getParent(), Op->getType());
if (IF->users().empty())
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 162 Lines • ▼ Show 20 Lines
PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT, PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT,
AssumptionCache &AC) AssumptionCache &AC)
: F(F) { : F(F) {
PredicateInfoBuilder Builder(*this, F, DT, AC); PredicateInfoBuilder Builder(*this, F, DT, AC);
Builder.buildPredicateInfo(); Builder.buildPredicateInfo();
} }
// Remove all declarations we created . The PredicateInfo consumers are PredicateInfo::~PredicateInfo() {}
fhahnUnsubmitted
Not Done
ReplyInline Actions

nit: move to the header?

fhahn: nit: move to the header?
// responsible for remove the ssa_copy calls created.
PredicateInfo::~PredicateInfo() {
// Collect function pointers in set first, as SmallSet uses a SmallVector
// internally and we have to remove the asserting value handles first.
SmallPtrSet<Function *, 20> FunctionPtrs;
for (auto &F : CreatedDeclarations)
FunctionPtrs.insert(&*F);
CreatedDeclarations.clear();
for (Function *F : FunctionPtrs) {
assert(F->user_begin() == F->user_end() &&
"PredicateInfo consumer did not remove all SSA copies.");
F->eraseFromParent();
}
}
Optional<PredicateConstraint> PredicateBase::getConstraint() const { Optional<PredicateConstraint> PredicateBase::getConstraint() const {
switch (Type) { switch (Type) {
case PT_Assume: case PT_Assume:
case PT_Branch: { case PT_Branch: {
bool TrueEdge = true; bool TrueEdge = true;
if (auto *PBranch = dyn_cast<PredicateBranch>(this)) if (auto *PBranch = dyn_cast<PredicateBranch>(this))
TrueEdge = PBranch->TrueEdge; TrueEdge = PBranch->TrueEdge;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
} }
void PredicateInfoPrinterLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const { void PredicateInfoPrinterLegacyPass::getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll(); AU.setPreservesAll();
AU.addRequiredTransitive<DominatorTreeWrapperPass>(); AU.addRequiredTransitive<DominatorTreeWrapperPass>();
AU.addRequired<AssumptionCacheTracker>(); AU.addRequired<AssumptionCacheTracker>();
} }
// Replace ssa_copy calls created by PredicateInfo with their operand.
static void replaceCreatedSSACopys(PredicateInfo &PredInfo, Function &F) {
for (auto I = inst_begin(F), E = inst_end(F); I != E;) {
Instruction *Inst = &*I++;
const auto *PI = PredInfo.getPredicateInfoFor(Inst);
auto *II = dyn_cast<IntrinsicInst>(Inst);
if (!PI || !II || II->getIntrinsicID() != Intrinsic::ssa_copy)
continue;
Inst->replaceAllUsesWith(II->getOperand(0));
Inst->eraseFromParent();
}
}
bool PredicateInfoPrinterLegacyPass::runOnFunction(Function &F) { bool PredicateInfoPrinterLegacyPass::runOnFunction(Function &F) {
auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC); auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC);
PredInfo->print(dbgs()); PredInfo->print(dbgs());
if (VerifyPredicateInfo) if (VerifyPredicateInfo)
PredInfo->verifyPredicateInfo(); PredInfo->verifyPredicateInfo();
replaceCreatedSSACopys(*PredInfo, F);
return false; return false;
} }
PreservedAnalyses PredicateInfoPrinterPass::run(Function &F, PreservedAnalyses PredicateInfoPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) { FunctionAnalysisManager &AM) {
auto &DT = AM.getResult<DominatorTreeAnalysis>(F); auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
auto &AC = AM.getResult<AssumptionAnalysis>(F); auto &AC = AM.getResult<AssumptionAnalysis>(F);
OS << "PredicateInfo for function: " << F.getName() << "\n"; OS << "PredicateInfo for function: " << F.getName() << "\n";
auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC); auto PredInfo = std::make_unique<PredicateInfo>(F, DT, AC);
PredInfo->print(OS); PredInfo->print(OS);
replaceCreatedSSACopys(*PredInfo, F);
return PreservedAnalyses::all(); return PreservedAnalyses::all();
} }
/// An assembly annotator class to print PredicateInfo information in /// An assembly annotator class to print PredicateInfo information in
/// comments. /// comments.
class PredicateInfoAnnotatedWriter : public AssemblyAnnotationWriter { class PredicateInfoAnnotatedWriter : public AssemblyAnnotationWriter {
friend class PredicateInfo; friend class PredicateInfo;
const PredicateInfo *PredInfo; const PredicateInfo *PredInfo;
▲ Show 20 Lines • Show All 55 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/NewGVN/pr33305.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
; CHECK-NEXT: store i32 [[TMP7]], i32* [[TMP5]], align 4, !tbaa !3 ; CHECK-NEXT: store i32 [[TMP7]], i32* [[TMP5]], align 4, !tbaa !3
; CHECK-NEXT: br label [[FN1_EXIT]] ; CHECK-NEXT: br label [[FN1_EXIT]]
; CHECK: fn1.exit: ; CHECK: fn1.exit:
; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* @a, align 4, !tbaa !3 ; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* @a, align 4, !tbaa !3
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TMP8]], 0 ; CHECK-NEXT: [[TOBOOL:%.*]] = icmp eq i32 [[TMP8]], 0
; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]] ; CHECK-NEXT: br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: [[PUTS2:%.*]] = tail call i32 @puts(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.2, i64 0, i64 0)) ; CHECK-NEXT: [[PUTS2:%.*]] = tail call i32 @puts(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.2, i64 0, i64 0))
; CHECK-NEXT: tail call void @abort() ; CHECK-NEXT: tail call void @abort() #4
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: if.end: ; CHECK: if.end:
; CHECK-NEXT: [[PUTS:%.*]] = tail call i32 @puts(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str, i64 0, i64 0)) ; CHECK-NEXT: [[PUTS:%.*]] = tail call i32 @puts(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str, i64 0, i64 0))
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
; ;
entry: entry:
%.pr.i = load i32, i32* @c, align 4, !tbaa !3 %.pr.i = load i32, i32* @c, align 4, !tbaa !3
%cmp13.i = icmp slt i32 %.pr.i, 1 %cmp13.i = icmp slt i32 %.pr.i, 1
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
declare void @foo(i1) declare void @foo(i1)
declare void @bar(i32) declare void @bar(i32)
define void @test3(i32 %x, i32 %y) { define void @test3(i32 %x, i32 %y) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; 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: [[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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK-NEXT: br i1 [[Z]], label [[BOTH_ZERO:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[Z]], label [[BOTH_ZERO:%.*]], label [[NOPE:%.*]]
; CHECK: both_zero: ; CHECK: both_zero:
; 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 20 Lines
; CHECK-NEXT: br i1 [[B:%.*]], label [[SW:%.*]], label [[CASE3:%.*]] ; CHECK-NEXT: br i1 [[B:%.*]], label [[SW:%.*]], label [[CASE3:%.*]]
; CHECK: sw: ; CHECK: sw:
; CHECK: i32 0, label [[CASE0:%.*]] ; CHECK: i32 0, label [[CASE0:%.*]]
; CHECK-NEXT: i32 1, label [[CASE1:%.*]] ; CHECK-NEXT: i32 1, label [[CASE1:%.*]]
; CHECK-NEXT: i32 2, label [[CASE0]] ; CHECK-NEXT: i32 2, label [[CASE0]]
; CHECK-NEXT: i32 3, label [[CASE3]] ; CHECK-NEXT: i32 3, label [[CASE3]]
; CHECK-NEXT: i32 4, label [[DEFAULT:%.*]] ; CHECK-NEXT: i32 4, label [[DEFAULT:%.*]]
; CHECK-NEXT: ] Edge: [label [[SW]],label %case1] ; CHECK-NEXT: ] Edge: [label [[SW]],label %case1]
; CHECK-NEXT: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X:%.*]]) ; CHECK-NEXT: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X:%.*]])
; CHECK-NEXT: switch i32 [[X]], label [[DEFAULT]] [ ; CHECK-NEXT: switch i32 [[X]], label [[DEFAULT]] [
; CHECK-NEXT: i32 0, label [[CASE0]] ; CHECK-NEXT: i32 0, label [[CASE0]]
; CHECK-NEXT: i32 1, label [[CASE1]] ; CHECK-NEXT: i32 1, label [[CASE1]]
; CHECK-NEXT: i32 2, label [[CASE0]] ; CHECK-NEXT: i32 2, label [[CASE0]]
; CHECK-NEXT: i32 3, label [[CASE3]] ; CHECK-NEXT: i32 3, label [[CASE3]]
; CHECK-NEXT: i32 4, label [[DEFAULT]] ; CHECK-NEXT: i32 4, label [[DEFAULT]]
; CHECK-NEXT: ] ; CHECK-NEXT: ]
; CHECK: default: ; CHECK: default:
Show All 30 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 @testor(i32 %x, i32 %y) { define void @testor(i32 %x, i32 %y) {
; CHECK-LABEL: @testor( ; CHECK-LABEL: @testor(
; 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: [[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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; 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 23 Linesneither:
call void @foo(i1 %z) call void @foo(i1 %z)
ret void ret void
} }
define void @testand(i32 %x, i32 %y) { define void @testand(i32 %x, i32 %y) {
; CHECK-LABEL: @testand( ; CHECK-LABEL: @testand(
; 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: [[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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; 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 23 Lines;; Should not insert on the false edge for and
call void @foo(i1 %z) call void @foo(i1 %z)
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: [[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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; 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 17 Linesnope:
ret void ret void
} }
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: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]])
fhahnUnsubmitted
Done
ReplyInline Actions

do you know why the order changed here?

fhahn: do you know why the order changed here?
jeroen.dobbelaereAuthorUnsubmitted
Done
ReplyInline Actions

Good that you asked. The reverted code now also reverses some of the insertions. Working on a fix.

jeroen.dobbelaere: Good that you asked. The reverted code now also reverses some of the insertions. Working on a…
; CHECK: [[TMP1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[TMP2:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]])
; CHECK: [[TMP2:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]]) ; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]])
; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]]) ; CHECK: [[TMP4:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]])
; CHECK: [[TMP4:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]]) ; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]]) ; CHECK: call void @llvm.assume(i1 [[Z]])
; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP5]]) ; CHECK: [[DOT0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP1]])
; CHECK: [[DOT01:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP4]]) ; CHECK: [[DOT01:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP2]])
; CHECK: [[DOT02:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP3]]) ; CHECK: [[DOT02:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP3]])
; CHECK: [[DOT03:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP2]]) ; CHECK: [[DOT03:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP4]])
; CHECK: [[DOT04:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP1]]) ; CHECK: [[DOT04:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP5]])
; CHECK-NEXT: br i1 [[TMP1]], label [[BOTH:%.*]], label [[NOPE:%.*]] ; CHECK-NEXT: br i1 [[TMP5]], label [[BOTH:%.*]], label [[NOPE:%.*]]
; CHECK: both: ; CHECK: both:
; CHECK-NEXT: call void @foo(i1 [[DOT0]]) ; CHECK-NEXT: call void @foo(i1 [[DOT0]])
; CHECK-NEXT: call void @foo(i1 [[DOT02]]) ; CHECK-NEXT: call void @foo(i1 [[DOT02]])
; CHECK-NEXT: call void @bar(i32 [[DOT01]]) ; CHECK-NEXT: call void @bar(i32 [[DOT01]])
; CHECK-NEXT: call void @bar(i32 [[DOT03]]) ; CHECK-NEXT: call void @bar(i32 [[DOT03]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; CHECK: nope: ; CHECK: nope:
; CHECK-NEXT: call void @foo(i1 [[DOT04]]) ; CHECK-NEXT: call void @foo(i1 [[DOT04]])
Show All 18 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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]])
; 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]]) ; 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 9 Linesboth:
call void @foo(i1 %xz) call void @foo(i1 %xz)
call void @foo(i1 %yz) call void @foo(i1 %yz)
call void @bar(i32 %x) call void @bar(i32 %x)
call void @bar(i32 %y) call void @bar(i32 %y)
ret void ret void
nope: nope:
call void @foo(i1 %z) call void @foo(i1 %z)
ret void ret void
} }
fhahnUnsubmitted
Done
ReplyInline Actions

no need to have {{.+}} here any longer?

fhahn: no need to have `{{.+}}` here any longer?

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