This is an archive of the discontinued LLVM Phabricator instance.

Differential D49126

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

Authored by fhahn on Jul 10 2018, 3:53 AM.

Details

Reviewers
efriedma
davide
Commits
rG36d2e25d5a83: [PredicateInfo] Use custom mangling to support ssa_copy with unnamed types.
rL337828: [PredicateInfo] Use custom mangling to support ssa_copy with unnamed types.
Summary

This is a workaround and it would be better to fix this generally, but
doing it generally is quite tricky. See D48541 and PR38117.

Doing it in PredicateInfo directly allows us to use the type address to
differentiate different unnamed types, because neither the created
declarations nor the ssa_copy calls should be visible after
PredicateInfo got destroyed.

Diff Detail

Repository
rL LLVM

Event Timeline

fhahn created this revision.Jul 10 2018, 3:53 AM
fhahn mentioned this in D48541: [Bitcode, Type] Assign deterministic IDs to unnamed types at creation time..Jul 10 2018, 3:55 AM
efriedma added a comment.Jul 10 2018, 12:21 PM

If you're going to do this, might as well just replace the whole implementation getMangledTypeStr with "return utostr((uintptr_t)Ty);".

include/llvm/Transforms/Utils/PredicateInfo.h
266 ↗(On Diff #154771)

AssertingVH.

fhahn updated this revision to Diff 154881.Jul 10 2018, 2:19 PM

Thanks Eli! I am not really happy with the solution, but as discussed in D48541 solving that generally seems quite an invasive change.

I also thought about bitcasting the argument and return type of the intrinsic to and from i8* (as you suggested as another alternative), but this makes the IR more verbose, as we would have to use casts for all struct types/pointers to structs as they could contain unnamed types at any level and it would make life harder for users of PredicateInfo.

fhahn added inline comments.Jul 10 2018, 2:20 PM
include/llvm/Transforms/Utils/PredicateInfo.h
266 ↗(On Diff #154771)

Will do tomorrow, I think SmallSet needs support for iterating first. I have a patch for that, but it is not committed yet, as there was a problem with GCC on some bots having problems with is_trivially_copy_constructible & co

fhahn updated this revision to Diff 155024.Jul 11 2018, 9:43 AM

Use SmallSet + AssertingVH

efriedma accepted this revision.Jul 11 2018, 11:47 AM

LGTM with one nit. I'm not really happy we're creating temporarily invalid IR, but it shouldn't cause any problems, and I don't see a better solution here.

lib/Transforms/Utils/PredicateInfo.cpp
729 ↗(On Diff #155024)

Can you just use a SmallVector here?

This revision is now accepted and ready to land.Jul 11 2018, 11:47 AM
fhahn added a comment.Jul 16 2018, 1:36 PM

Thank you very much Eli! There was a problem with the SmallSet iterator because of MSVC STL's std::set iterator not being trivially copy constructible. I'll commit this once I manged to resolve the SmallSet iterator issue.

Closed by commit rL337828: [PredicateInfo] Use custom mangling to support ssa_copy with unnamed types. (authored by fhahn). · Explain WhyJul 24 2018, 7:50 AM
This revision was automatically updated to reflect the committed changes.
jeroen.dobbelaere mentioned this in D91661: Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with unnamed types..Nov 17 2020, 2:35 PM
jeroen.dobbelaere mentioned this in rG77080a1eb606: Revert of D49126 [PredicateInfo] Use custom mangling to support ssa_copy with….Mar 20 2021, 3:39 AM
jeroen.dobbelaere added a reverting change: D106147: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types..Jul 16 2021, 6:26 AM
jeroen.dobbelaere mentioned this in rGdc5570d149ca: Revert "Revert of D49126 [PredicateInfo] Use custom mangling to support….Jul 28 2021, 10:31 AM
jeroen.dobbelaere added a reverting change: rG03b8c69d06f8: [PredicateInfo] Use Intrinsic::getDeclaration now that it handles unnamed types..

Revision Contents

PathSize
llvm/
trunk/
include/
llvm/
Transforms/
Utils/
4 lines
lib/
Transforms/
Utils/
62 lines
test/
Other/
4 lines
Transforms/
NewGVN/
2 lines
Util/
PredicateInfo/
54 lines
8 lines
18 lines
52 lines
36 lines

Diff 157036

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

Show First 20 Lines • Show All 48 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/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.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/ADT/iterator.h" #include "llvm/ADT/iterator.h"
#include "llvm/Analysis/AssumptionCache.h" #include "llvm/Analysis/AssumptionCache.h"
#include "llvm/IR/BasicBlock.h" #include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/OperandTraits.h" #include "llvm/IR/OperandTraits.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
#include "llvm/IR/Use.h" #include "llvm/IR/Use.h"
#include "llvm/IR/User.h" #include "llvm/IR/User.h"
#include "llvm/IR/Value.h" #include "llvm/IR/Value.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/PassAnalysisSupport.h" #include "llvm/PassAnalysisSupport.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/Transforms/Utils/OrderedInstructions.h" #include "llvm/Transforms/Utils/OrderedInstructions.h"
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Linesprivate:
SmallVector<ValueInfo, 32> ValueInfos; SmallVector<ValueInfo, 32> ValueInfos;
// This gives the index into the ValueInfos array for a given Value. Because // This gives the index into the ValueInfos array for a given Value. Because
// 0 is not a valid Value Info index, you can use DenseMap::lookup and tell // 0 is not a valid Value Info index, you can use DenseMap::lookup and tell
// whether it returned a valid result. // whether it returned a valid result.
DenseMap<Value *, unsigned int> ValueInfoNums; DenseMap<Value *, unsigned int> ValueInfoNums;
// The set of edges along which we can only handle phi uses, due to critical // The set of edges along which we can only handle phi uses, due to critical
// edges. // edges.
DenseSet<std::pair<BasicBlock *, BasicBlock *>> EdgeUsesOnly; DenseSet<std::pair<BasicBlock *, BasicBlock *>> EdgeUsesOnly;
// 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/trunk/lib/Transforms/Utils/PredicateInfo.cpp

Show All 11 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/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/DebugCounter.h" #include "llvm/Support/DebugCounter.h"
#include "llvm/Support/FormattedStream.h" #include "llvm/Support/FormattedStream.h"
▲ Show 20 Lines • Show All 439 Lines • ▼ Show 20 Linesvoid PredicateInfo::buildPredicateInfo() {
for (auto &Assume : AC.assumptions()) { for (auto &Assume : AC.assumptions()) {
if (auto *II = dyn_cast_or_null<IntrinsicInst>(Assume)) if (auto *II = dyn_cast_or_null<IntrinsicInst>(Assume))
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)));
}
// 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 *PredicateInfo::materializeStack(unsigned int &Counter, Value *PredicateInfo::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 12 Lines for (auto RenameIter = RenameStack.end() - Start;
auto *ValInfo = Result.PInfo; auto *ValInfo = Result.PInfo;
// 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 = Intrinsic::getDeclaration( Function *IF = getCopyDeclaration(F.getParent(), Op->getType());
F.getParent(), Intrinsic::ssa_copy, Op->getType()); if (IF->user_begin() == IF->user_end())
CreatedDeclarations.insert(IF);
CallInst *PIC = CallInst *PIC =
B.CreateCall(IF, Op, Op->getName() + "." + Twine(Counter++)); B.CreateCall(IF, Op, Op->getName() + "." + Twine(Counter++));
PredicateMap.insert({PIC, ValInfo}); 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");
IRBuilder<> B(PAssume->AssumeInst); IRBuilder<> B(PAssume->AssumeInst);
Function *IF = Intrinsic::getDeclaration( Function *IF = getCopyDeclaration(F.getParent(), Op->getType());
F.getParent(), Intrinsic::ssa_copy, Op->getType()); if (IF->user_begin() == IF->user_end())
CreatedDeclarations.insert(IF);
CallInst *PIC = B.CreateCall(IF, Op); CallInst *PIC = B.CreateCall(IF, Op);
PredicateMap.insert({PIC, ValInfo}); PredicateMap.insert({PIC, ValInfo});
Result.Def = PIC; Result.Def = PIC;
} }
} }
return RenameStack.back().Def; return RenameStack.back().Def;
} }
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT, PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT,
AssumptionCache &AC) AssumptionCache &AC)
: F(F), DT(DT), AC(AC), OI(&DT) { : F(F), DT(DT), AC(AC), OI(&DT) {
// Push an empty operand info so that we can detect 0 as not finding one // Push an empty operand info so that we can detect 0 as not finding one
ValueInfos.resize(1); ValueInfos.resize(1);
buildPredicateInfo(); buildPredicateInfo();
} }
PredicateInfo::~PredicateInfo() {} // Remove all declarations we created . The PredicateInfo consumers are
// 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();
}
}
void PredicateInfo::verifyPredicateInfo() const {} void PredicateInfo::verifyPredicateInfo() const {}
char PredicateInfoPrinterLegacyPass::ID = 0; char PredicateInfoPrinterLegacyPass::ID = 0;
PredicateInfoPrinterLegacyPass::PredicateInfoPrinterLegacyPass() PredicateInfoPrinterLegacyPass::PredicateInfoPrinterLegacyPass()
: FunctionPass(ID) { : FunctionPass(ID) {
initializePredicateInfoPrinterLegacyPassPass( initializePredicateInfoPrinterLegacyPassPass(
*PassRegistry::getPassRegistry()); *PassRegistry::getPassRegistry());
} }
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 = make_unique<PredicateInfo>(F, DT, AC); auto PredInfo = 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";
make_unique<PredicateInfo>(F, DT, AC)->print(OS); auto PredInfo = make_unique<PredicateInfo>(F, DT, AC);
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 52 Lines • Show Last 20 Lines

llvm/trunk/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 -analyze < %s 2>&1 | FileCheck %s ; RUN: opt -debug-counter=predicateinfo-rename-skip=1,predicateinfo-rename-count=1 -print-predicateinfo -analyze < %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(i1 [[TMP23]]) ; CHECK: [[TMP23_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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(i1 [[TMP23_0]]) ; CHECK: [[TMP23_0_1:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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/trunk/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() #4 ; CHECK-NEXT: tail call void @abort()
; 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/trunk/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: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]])
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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(i32 [[X:%.*]]) ; CHECK-NEXT: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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.f32(float [[X]]) ; CHECK: [[X_0:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[X]])
; CHECK: [[X_1:%.*]] = call float @llvm.ssa.copy.f32(float [[X]]) ; CHECK: [[X_1:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[X]])
; CHECK: [[Y_0:%.*]] = call float @llvm.ssa.copy.f32(float [[Y]]) ; CHECK: [[Y_0:%.*]] = call float @llvm.ssa.copy.{{.+}}(float [[Y]])
; CHECK: [[Y_1:%.*]] = call float @llvm.ssa.copy.f32(float [[Y]]) ; CHECK: [[Y_1:%.*]] = call float @llvm.ssa.copy.{{.+}}(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(i32 [[I]]) ; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[I]])
; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[J]]) ; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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: [[J_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[J]]) ; CHECK: [[J_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[J]])
; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[I]]) ; CHECK: [[I_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[I]])
; 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(i32 [[V0]]) ; CHECK: [[V0_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[V0]])
; CHECK: [[V1_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[V1]]) ; CHECK: [[V1_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[V0_0]]) ; CHECK: [[V0_0_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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/trunk/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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X2]]) ; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X2]]) ; CHECK: [[X2_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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/trunk/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 -analyze < %s 2>&1 | FileCheck %s ; RUN: opt -print-predicateinfo -analyze < %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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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(i32 [[X:%.*]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(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.f64(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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.f64(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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.f64(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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.f64(double [[Y]]) ; CHECK: [[Y_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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.f64(double [[Z]]) ; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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.f64(double [[Z]]) ; CHECK: [[Z_0:%.*]] = call double @llvm.ssa.copy.{{.+}}(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/trunk/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 < %s 2>&1 | FileCheck %s ; RUN: opt -print-predicateinfo < %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: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]])
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[Y_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]]) ; CHECK: [[XZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]])
; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]]) ; CHECK: [[YZ_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]])
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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: [[X_0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[X_0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[X_0_1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X_0]]) ; CHECK: [[X_0_1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X_0]])
; CHECK: [[XGT_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XGT]]) ; CHECK: [[XGT_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XGT]])
; CHECK: [[XLT_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XLT]]) ; CHECK: [[XLT_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XLT]])
; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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: [[TMP1:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[X]]) ; CHECK: [[TMP1:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[X]])
; CHECK: [[TMP2:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[Y]]) ; CHECK: [[TMP2:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[Y]])
; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[XZ]]) ; CHECK: [[TMP3:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[XZ]])
; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[YZ]]) ; CHECK: [[TMP4:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[YZ]])
; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[TMP5:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[Z]])
; CHECK-NEXT: call void @llvm.assume(i1 [[TMP5]]) ; CHECK-NEXT: call void @llvm.assume(i1 [[TMP5]])
; CHECK: [[DOT0:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP1]]) ; CHECK: [[DOT0:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP1]])
; CHECK: [[DOT01:%.*]] = call i32 @llvm.ssa.copy.i32(i32 [[TMP2]]) ; CHECK: [[DOT01:%.*]] = call i32 @llvm.ssa.copy.{{.+}}(i32 [[TMP2]])
; CHECK: [[DOT02:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP3]]) ; CHECK: [[DOT02:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP3]])
; CHECK: [[DOT03:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP4]]) ; CHECK: [[DOT03:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP4]])
; CHECK: [[DOT04:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[TMP5]]) ; CHECK: [[DOT04:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(i1 [[TMP5]])
; 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 [[DOT02]]) ; CHECK-NEXT: call void @foo(i1 [[DOT02]])
; CHECK-NEXT: call void @foo(i1 [[DOT03]]) ; CHECK-NEXT: call void @foo(i1 [[DOT03]])
; CHECK-NEXT: call void @bar(i32 [[DOT0]]) ; CHECK-NEXT: call void @bar(i32 [[DOT0]])
; CHECK-NEXT: call void @bar(i32 [[DOT01]]) ; CHECK-NEXT: call void @bar(i32 [[DOT01]])
; 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: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.i1(i1 [[Z]]) ; CHECK: [[Z_0:%.*]] = call i1 @llvm.ssa.copy.{{.+}}(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 18 Lines

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

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