RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-26 04:32:44 +01:00
Code Issues Projects Releases Wiki Activity

[PredicateInfo] Fold PredicateWithCondition into PredicateBase (NFC).

Browse Source 
Each concrete instance of a predicate has a condition (also noted in the
original PredicateBase comment) and to me it seems like there is no
clear benefit of having both PredicateBase and PredicateWithCondition
and they can be folded together.

Reviewers: nikic, efriedma

Reviewed By: nikic

Differential Revision: https://reviews.llvm.org/D84089
This commit is contained in:
Florian Hahn 2020-07-18 15:59:51 +01:00
parent 8e3d4ca0bb
commit 85de6c0e87
2 changed files with 10 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
include/llvm/Transforms/Utils/PredicateInfo.h
View File

@ -83,37 +83,31 @@ public:
// predicates, this is different to OriginalOp which refers to the initial
// operand.
Value *RenamedOp;
// The condition associated with this predicate.
Value *Condition;
PredicateBase(const PredicateBase &) = delete;
PredicateBase &operator=(const PredicateBase &) = delete;
PredicateBase() = delete;
virtual ~PredicateBase() = default;
protected:
PredicateBase(PredicateType PT, Value *Op) : Type(PT), OriginalOp(Op) {}
};
class PredicateWithCondition : public PredicateBase {
public:
Value *Condition;
static bool classof(const PredicateBase *PB) {
return PB->Type == PT_Assume || PB->Type == PT_Branch ||
PB->Type == PT_Switch;
}
protected:
PredicateWithCondition(PredicateType PT, Value *Op, Value *Condition)
: PredicateBase(PT, Op), Condition(Condition) {}
PredicateBase(PredicateType PT, Value *Op, Value *Condition)
: Type(PT), OriginalOp(Op), Condition(Condition) {}
};
// Provides predicate information for assumes. Since assumes are always true,
// we simply provide the assume instruction, so you can tell your relative
// position to it.
class PredicateAssume : public PredicateWithCondition {
class PredicateAssume : public PredicateBase {
public:
IntrinsicInst *AssumeInst;
PredicateAssume(Value *Op, IntrinsicInst *AssumeInst, Value *Condition)
: PredicateWithCondition(PT_Assume, Op, Condition),
AssumeInst(AssumeInst) {}
: PredicateBase(PT_Assume, Op, Condition), AssumeInst(AssumeInst) {}
PredicateAssume() = delete;
static bool classof(const PredicateBase *PB) {
return PB->Type == PT_Assume;
@ -123,7 +117,7 @@ public:
// Mixin class for edge predicates. The FROM block is the block where the
// predicate originates, and the TO block is the block where the predicate is
// valid.
class PredicateWithEdge : public PredicateWithCondition {
class PredicateWithEdge : public PredicateBase {
public:
BasicBlock *From;
BasicBlock *To;
@ -135,7 +129,7 @@ public:
protected:
PredicateWithEdge(PredicateType PType, Value *Op, BasicBlock *From,
BasicBlock *To, Value *Cond)
: PredicateWithCondition(PType, Op, Cond), From(From), To(To) {}
: PredicateBase(PType, Op, Cond), From(From), To(To) {}
};
// Provides predicate information for branches.

6
lib/Transforms/Scalar/NewGVN.cpp
View File

@ -1539,12 +1539,8 @@ NewGVN::performSymbolicPredicateInfoEvaluation(Instruction *I) const {
LLVM_DEBUG(dbgs() << "Found predicate info from instruction !\n");
auto *PWC = dyn_cast<PredicateWithCondition>(PI);
if (!PWC)
return nullptr;
auto *CopyOf = I->getOperand(0);
auto *Cond = PWC->Condition;
auto *Cond = PI->Condition;
// If this a copy of the condition, it must be either true or false depending
// on the predicate info type and edge.