mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-25 00:29:20 +00:00
Move getTrue() and getFalse() to 2.5-like APIs.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@77685 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
ed47a0409b
commit
5defacc6e6
@ -56,6 +56,9 @@ protected:
|
||||
return User::operator new(s, 0);
|
||||
}
|
||||
public:
|
||||
static ConstantInt* getTrue(LLVMContext &Context);
|
||||
static ConstantInt* getFalse(LLVMContext &Context);
|
||||
|
||||
/// If Ty is a vector type, return a Constant with a splat of the given
|
||||
/// value. Otherwise return a ConstantInt for the given value.
|
||||
static Constant* get(const Type* Ty, uint64_t V, bool isSigned = false);
|
||||
|
@ -73,10 +73,6 @@ public:
|
||||
/// @brief Get the all ones value
|
||||
Constant* getAllOnesValue(const Type* Ty);
|
||||
|
||||
// ConstantInt accessors
|
||||
ConstantInt* getTrue();
|
||||
ConstantInt* getFalse();
|
||||
|
||||
// MDNode accessors
|
||||
MDNode* getMDNode(Value* const* Vals, unsigned NumVals);
|
||||
|
||||
|
@ -155,7 +155,7 @@ void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
|
||||
}
|
||||
|
||||
// Constant condition variables mean the branch can only go a single way
|
||||
Succs[C == Context->getFalse()] = true;
|
||||
Succs[C == ConstantInt::getFalse(*Context)] = true;
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -1753,11 +1753,11 @@ bool LLParser::ParseValID(ValID &ID) {
|
||||
ID.Kind = ValID::t_APFloat;
|
||||
break;
|
||||
case lltok::kw_true:
|
||||
ID.ConstantVal = Context.getTrue();
|
||||
ID.ConstantVal = ConstantInt::getTrue(Context);
|
||||
ID.Kind = ValID::t_Constant;
|
||||
break;
|
||||
case lltok::kw_false:
|
||||
ID.ConstantVal = Context.getFalse();
|
||||
ID.ConstantVal = ConstantInt::getFalse(Context);
|
||||
ID.Kind = ValID::t_Constant;
|
||||
break;
|
||||
case lltok::kw_null: ID.Kind = ValID::t_Null; break;
|
||||
|
@ -1149,7 +1149,7 @@ SelectionDAGLowering::EmitBranchForMergedCondition(Value *Cond,
|
||||
}
|
||||
|
||||
// Create a CaseBlock record representing this branch.
|
||||
CaseBlock CB(ISD::SETEQ, Cond, DAG.getContext()->getTrue(),
|
||||
CaseBlock CB(ISD::SETEQ, Cond, ConstantInt::getTrue(*DAG.getContext()),
|
||||
NULL, TBB, FBB, CurBB);
|
||||
SwitchCases.push_back(CB);
|
||||
}
|
||||
@ -1304,7 +1304,7 @@ void SelectionDAGLowering::visitBr(BranchInst &I) {
|
||||
}
|
||||
|
||||
// Create a CaseBlock record representing this branch.
|
||||
CaseBlock CB(ISD::SETEQ, CondVal, DAG.getContext()->getTrue(),
|
||||
CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(*DAG.getContext()),
|
||||
NULL, Succ0MBB, Succ1MBB, CurMBB);
|
||||
// Use visitSwitchCase to actually insert the fast branch sequence for this
|
||||
// cond branch.
|
||||
@ -1322,10 +1322,10 @@ void SelectionDAGLowering::visitSwitchCase(CaseBlock &CB) {
|
||||
if (CB.CmpMHS == NULL) {
|
||||
// Fold "(X == true)" to X and "(X == false)" to !X to
|
||||
// handle common cases produced by branch lowering.
|
||||
if (CB.CmpRHS == DAG.getContext()->getTrue() &&
|
||||
if (CB.CmpRHS == ConstantInt::getTrue(*DAG.getContext()) &&
|
||||
CB.CC == ISD::SETEQ)
|
||||
Cond = CondLHS;
|
||||
else if (CB.CmpRHS == DAG.getContext()->getFalse() &&
|
||||
else if (CB.CmpRHS == ConstantInt::getFalse(*DAG.getContext()) &&
|
||||
CB.CC == ISD::SETEQ) {
|
||||
SDValue True = DAG.getConstant(1, CondLHS.getValueType());
|
||||
Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
|
||||
|
@ -865,7 +865,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
|
||||
GlobalVariable *InitBool =
|
||||
new GlobalVariable(Context, Type::Int1Ty, false,
|
||||
GlobalValue::InternalLinkage,
|
||||
Context.getFalse(), GV->getName()+".init",
|
||||
ConstantInt::getFalse(Context), GV->getName()+".init",
|
||||
GV->isThreadLocal());
|
||||
bool InitBoolUsed = false;
|
||||
|
||||
@ -886,7 +886,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
|
||||
default: llvm_unreachable("Unknown ICmp Predicate!");
|
||||
case ICmpInst::ICMP_ULT:
|
||||
case ICmpInst::ICMP_SLT:
|
||||
LV = Context.getFalse(); // X < null -> always false
|
||||
LV = ConstantInt::getFalse(Context); // X < null -> always false
|
||||
break;
|
||||
case ICmpInst::ICMP_ULE:
|
||||
case ICmpInst::ICMP_SLE:
|
||||
@ -908,7 +908,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
|
||||
} else {
|
||||
StoreInst *SI = cast<StoreInst>(GV->use_back());
|
||||
// The global is initialized when the store to it occurs.
|
||||
new StoreInst(Context.getTrue(), InitBool, SI);
|
||||
new StoreInst(ConstantInt::getTrue(Context), InitBool, SI);
|
||||
SI->eraseFromParent();
|
||||
}
|
||||
|
||||
@ -1583,7 +1583,7 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal,
|
||||
|
||||
// Create the new global, initializing it to false.
|
||||
GlobalVariable *NewGV = new GlobalVariable(Context, Type::Int1Ty, false,
|
||||
GlobalValue::InternalLinkage, Context.getFalse(),
|
||||
GlobalValue::InternalLinkage, ConstantInt::getFalse(Context),
|
||||
GV->getName()+".b",
|
||||
GV->isThreadLocal());
|
||||
GV->getParent()->getGlobalList().insert(GV, NewGV);
|
||||
|
@ -1385,9 +1385,11 @@ bool GVN::processInstruction(Instruction *I,
|
||||
BasicBlock* falseSucc = BI->getSuccessor(1);
|
||||
|
||||
if (trueSucc->getSinglePredecessor())
|
||||
localAvail[trueSucc]->table[condVN] = trueSucc->getContext().getTrue();
|
||||
localAvail[trueSucc]->table[condVN] =
|
||||
ConstantInt::getTrue(trueSucc->getContext());
|
||||
if (falseSucc->getSinglePredecessor())
|
||||
localAvail[falseSucc]->table[condVN] = trueSucc->getContext().getFalse();
|
||||
localAvail[falseSucc]->table[condVN] =
|
||||
ConstantInt::getFalse(trueSucc->getContext());
|
||||
|
||||
return false;
|
||||
|
||||
|
@ -2871,8 +2871,8 @@ bool InstCombiner::SimplifyDivRemOfSelect(BinaryOperator &I) {
|
||||
*I = SI->getOperand(NonNullOperand);
|
||||
AddToWorkList(BBI);
|
||||
} else if (*I == SelectCond) {
|
||||
*I = NonNullOperand == 1 ? Context->getTrue() :
|
||||
Context->getFalse();
|
||||
*I = NonNullOperand == 1 ? ConstantInt::getTrue(*Context) :
|
||||
ConstantInt::getFalse(*Context);
|
||||
AddToWorkList(BBI);
|
||||
}
|
||||
}
|
||||
@ -3366,7 +3366,7 @@ static Value *getICmpValue(bool sign, unsigned code, Value *LHS, Value *RHS,
|
||||
LLVMContext *Context) {
|
||||
switch (code) {
|
||||
default: llvm_unreachable("Illegal ICmp code!");
|
||||
case 0: return Context->getFalse();
|
||||
case 0: return ConstantInt::getFalse(*Context);
|
||||
case 1:
|
||||
if (sign)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_SGT, LHS, RHS);
|
||||
@ -3389,7 +3389,7 @@ static Value *getICmpValue(bool sign, unsigned code, Value *LHS, Value *RHS,
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_SLE, LHS, RHS);
|
||||
else
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_ULE, LHS, RHS);
|
||||
case 7: return Context->getTrue();
|
||||
case 7: return ConstantInt::getTrue(*Context);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3435,7 +3435,7 @@ static Value *getFCmpValue(bool isordered, unsigned code,
|
||||
return new FCmpInst(*Context, FCmpInst::FCMP_OLE, LHS, RHS);
|
||||
else
|
||||
return new FCmpInst(*Context, FCmpInst::FCMP_ULE, LHS, RHS);
|
||||
case 7: return Context->getTrue();
|
||||
case 7: return ConstantInt::getTrue(*Context);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3820,7 +3820,7 @@ Instruction *InstCombiner::FoldAndOfICmps(Instruction &I,
|
||||
case ICmpInst::ICMP_EQ: // (X == 13 & X == 15) -> false
|
||||
case ICmpInst::ICMP_UGT: // (X == 13 & X > 15) -> false
|
||||
case ICmpInst::ICMP_SGT: // (X == 13 & X > 15) -> false
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
case ICmpInst::ICMP_NE: // (X == 13 & X != 15) -> X == 13
|
||||
case ICmpInst::ICMP_ULT: // (X == 13 & X < 15) -> X == 13
|
||||
case ICmpInst::ICMP_SLT: // (X == 13 & X < 15) -> X == 13
|
||||
@ -3858,7 +3858,7 @@ Instruction *InstCombiner::FoldAndOfICmps(Instruction &I,
|
||||
default: llvm_unreachable("Unknown integer condition code!");
|
||||
case ICmpInst::ICMP_EQ: // (X u< 13 & X == 15) -> false
|
||||
case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
case ICmpInst::ICMP_SGT: // (X u< 13 & X s> 15) -> no change
|
||||
break;
|
||||
case ICmpInst::ICMP_NE: // (X u< 13 & X != 15) -> X u< 13
|
||||
@ -3873,7 +3873,7 @@ Instruction *InstCombiner::FoldAndOfICmps(Instruction &I,
|
||||
default: llvm_unreachable("Unknown integer condition code!");
|
||||
case ICmpInst::ICMP_EQ: // (X s< 13 & X == 15) -> false
|
||||
case ICmpInst::ICMP_SGT: // (X s< 13 & X s> 15) -> false
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
case ICmpInst::ICMP_UGT: // (X s< 13 & X u> 15) -> no change
|
||||
break;
|
||||
case ICmpInst::ICMP_NE: // (X s< 13 & X != 15) -> X < 13
|
||||
@ -3937,7 +3937,7 @@ Instruction *InstCombiner::FoldAndOfFCmps(Instruction &I, FCmpInst *LHS,
|
||||
// If either of the constants are nans, then the whole thing returns
|
||||
// false.
|
||||
if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN())
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
return new FCmpInst(*Context, FCmpInst::FCMP_ORD,
|
||||
LHS->getOperand(0), RHS->getOperand(0));
|
||||
}
|
||||
@ -3968,7 +3968,7 @@ Instruction *InstCombiner::FoldAndOfFCmps(Instruction &I, FCmpInst *LHS,
|
||||
return new FCmpInst(*Context, (FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS);
|
||||
|
||||
if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
if (Op0CC == FCmpInst::FCMP_TRUE)
|
||||
return ReplaceInstUsesWith(I, RHS);
|
||||
if (Op1CC == FCmpInst::FCMP_TRUE)
|
||||
@ -3992,7 +3992,7 @@ Instruction *InstCombiner::FoldAndOfFCmps(Instruction &I, FCmpInst *LHS,
|
||||
// uno && oeq -> uno && (ord && eq) -> false
|
||||
// uno && ord -> false
|
||||
if (!Op0Ordered)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
// ord && ueq -> ord && (uno || eq) -> oeq
|
||||
return cast<Instruction>(getFCmpValue(true, Op1Pred,
|
||||
Op0LHS, Op0RHS, Context));
|
||||
@ -4553,7 +4553,7 @@ Instruction *InstCombiner::FoldOrOfICmps(Instruction &I,
|
||||
case ICmpInst::ICMP_NE: // (X != 13 | X != 15) -> true
|
||||
case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true
|
||||
case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
}
|
||||
break;
|
||||
case ICmpInst::ICMP_ULT:
|
||||
@ -4608,7 +4608,7 @@ Instruction *InstCombiner::FoldOrOfICmps(Instruction &I,
|
||||
break;
|
||||
case ICmpInst::ICMP_NE: // (X u> 13 | X != 15) -> true
|
||||
case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
case ICmpInst::ICMP_SLT: // (X u> 13 | X s< 15) -> no change
|
||||
break;
|
||||
}
|
||||
@ -4623,7 +4623,7 @@ Instruction *InstCombiner::FoldOrOfICmps(Instruction &I,
|
||||
break;
|
||||
case ICmpInst::ICMP_NE: // (X s> 13 | X != 15) -> true
|
||||
case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
case ICmpInst::ICMP_ULT: // (X s> 13 | X u< 15) -> no change
|
||||
break;
|
||||
}
|
||||
@ -4642,7 +4642,7 @@ Instruction *InstCombiner::FoldOrOfFCmps(Instruction &I, FCmpInst *LHS,
|
||||
// If either of the constants are nans, then the whole thing returns
|
||||
// true.
|
||||
if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN())
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
|
||||
// Otherwise, no need to compare the two constants, compare the
|
||||
// rest.
|
||||
@ -4675,7 +4675,7 @@ Instruction *InstCombiner::FoldOrOfFCmps(Instruction &I, FCmpInst *LHS,
|
||||
return new FCmpInst(*Context, (FCmpInst::Predicate)Op0CC,
|
||||
Op0LHS, Op0RHS);
|
||||
if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0CC == FCmpInst::FCMP_FALSE)
|
||||
return ReplaceInstUsesWith(I, RHS);
|
||||
if (Op1CC == FCmpInst::FCMP_FALSE)
|
||||
@ -5061,7 +5061,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
|
||||
|
||||
|
||||
if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) {
|
||||
if (RHS == Context->getTrue() && Op0->hasOneUse()) {
|
||||
if (RHS == ConstantInt::getTrue(*Context) && Op0->hasOneUse()) {
|
||||
// xor (cmp A, B), true = not (cmp A, B) = !cmp A, B
|
||||
if (ICmpInst *ICI = dyn_cast<ICmpInst>(Op0))
|
||||
return new ICmpInst(*Context, ICI->getInversePredicate(),
|
||||
@ -5079,7 +5079,7 @@ Instruction *InstCombiner::visitXor(BinaryOperator &I) {
|
||||
Instruction::CastOps Opcode = Op0C->getOpcode();
|
||||
if (Opcode == Instruction::ZExt || Opcode == Instruction::SExt) {
|
||||
if (RHS == ConstantExpr::getCast(Opcode,
|
||||
Context->getTrue(),
|
||||
ConstantInt::getTrue(*Context),
|
||||
Op0C->getDestTy())) {
|
||||
Instruction *NewCI = InsertNewInstBefore(CmpInst::Create(
|
||||
*Context,
|
||||
@ -5731,9 +5731,9 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
Pred = ICmpInst::ICMP_NE;
|
||||
break;
|
||||
case FCmpInst::FCMP_ORD:
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
case FCmpInst::FCMP_UNO:
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
}
|
||||
|
||||
const IntegerType *IntTy = cast<IntegerType>(LHSI->getOperand(0)->getType());
|
||||
@ -5753,8 +5753,8 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
if (SMax.compare(RHS) == APFloat::cmpLessThan) { // smax < 13123.0
|
||||
if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SLT ||
|
||||
Pred == ICmpInst::ICMP_SLE)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
}
|
||||
} else {
|
||||
// If the RHS value is > UnsignedMax, fold the comparison. This handles
|
||||
@ -5765,8 +5765,8 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
if (UMax.compare(RHS) == APFloat::cmpLessThan) { // umax < 13123.0
|
||||
if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_ULT ||
|
||||
Pred == ICmpInst::ICMP_ULE)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
}
|
||||
}
|
||||
|
||||
@ -5778,8 +5778,8 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // smin > 12312.0
|
||||
if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT ||
|
||||
Pred == ICmpInst::ICMP_SGE)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
}
|
||||
}
|
||||
|
||||
@ -5801,14 +5801,14 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
switch (Pred) {
|
||||
default: llvm_unreachable("Unexpected integer comparison!");
|
||||
case ICmpInst::ICMP_NE: // (float)int != 4.4 --> true
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
case ICmpInst::ICMP_EQ: // (float)int == 4.4 --> false
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
case ICmpInst::ICMP_ULE:
|
||||
// (float)int <= 4.4 --> int <= 4
|
||||
// (float)int <= -4.4 --> false
|
||||
if (RHS.isNegative())
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_SLE:
|
||||
// (float)int <= 4.4 --> int <= 4
|
||||
@ -5820,7 +5820,7 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
// (float)int < -4.4 --> false
|
||||
// (float)int < 4.4 --> int <= 4
|
||||
if (RHS.isNegative())
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
Pred = ICmpInst::ICMP_ULE;
|
||||
break;
|
||||
case ICmpInst::ICMP_SLT:
|
||||
@ -5833,7 +5833,7 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
// (float)int > 4.4 --> int > 4
|
||||
// (float)int > -4.4 --> true
|
||||
if (RHS.isNegative())
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_SGT:
|
||||
// (float)int > 4.4 --> int > 4
|
||||
@ -5845,7 +5845,7 @@ Instruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I,
|
||||
// (float)int >= -4.4 --> true
|
||||
// (float)int >= 4.4 --> int > 4
|
||||
if (!RHS.isNegative())
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
Pred = ICmpInst::ICMP_UGT;
|
||||
break;
|
||||
case ICmpInst::ICMP_SGE:
|
||||
@ -5869,9 +5869,9 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
|
||||
|
||||
// Fold trivial predicates.
|
||||
if (I.getPredicate() == FCmpInst::FCMP_FALSE)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
if (I.getPredicate() == FCmpInst::FCMP_TRUE)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
|
||||
// Simplify 'fcmp pred X, X'
|
||||
if (Op0 == Op1) {
|
||||
@ -5880,11 +5880,11 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
|
||||
case FCmpInst::FCMP_UEQ: // True if unordered or equal
|
||||
case FCmpInst::FCMP_UGE: // True if unordered, greater than, or equal
|
||||
case FCmpInst::FCMP_ULE: // True if unordered, less than, or equal
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
case FCmpInst::FCMP_OGT: // True if ordered and greater than
|
||||
case FCmpInst::FCMP_OLT: // True if ordered and less than
|
||||
case FCmpInst::FCMP_ONE: // True if ordered and operands are unequal
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
|
||||
case FCmpInst::FCMP_UNO: // True if unordered: isnan(X) | isnan(Y)
|
||||
case FCmpInst::FCMP_ULT: // True if unordered or less than
|
||||
@ -5915,11 +5915,11 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) {
|
||||
if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) {
|
||||
if (CFP->getValueAPF().isNaN()) {
|
||||
if (FCmpInst::isOrdered(I.getPredicate())) // True if ordered and...
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
assert(FCmpInst::isUnordered(I.getPredicate()) &&
|
||||
"Comparison must be either ordered or unordered!");
|
||||
// True if unordered.
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
}
|
||||
}
|
||||
|
||||
@ -6069,22 +6069,22 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
default: break;
|
||||
case ICmpInst::ICMP_ULE:
|
||||
if (CI->isMaxValue(false)) // A <=u MAX -> TRUE
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_ULT, Op0,
|
||||
AddOne(CI, Context));
|
||||
case ICmpInst::ICMP_SLE:
|
||||
if (CI->isMaxValue(true)) // A <=s MAX -> TRUE
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_SLT, Op0,
|
||||
AddOne(CI, Context));
|
||||
case ICmpInst::ICMP_UGE:
|
||||
if (CI->isMinValue(false)) // A >=u MIN -> TRUE
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_UGT, Op0,
|
||||
SubOne(CI, Context));
|
||||
case ICmpInst::ICMP_SGE:
|
||||
if (CI->isMinValue(true)) // A >=s MIN -> TRUE
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_SGT, Op0,
|
||||
SubOne(CI, Context));
|
||||
}
|
||||
@ -6144,17 +6144,17 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
default: llvm_unreachable("Unknown icmp opcode!");
|
||||
case ICmpInst::ICMP_EQ:
|
||||
if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max))
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_NE:
|
||||
if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max))
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_ULT:
|
||||
if (Op0Max.ult(Op1Min)) // A <u B -> true if max(A) < min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Min.uge(Op1Max)) // A <u B -> false if min(A) >= max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
if (Op1Min == Op0Max) // A <u B -> A != B if max(A) == min(B)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_NE, Op0, Op1);
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
|
||||
@ -6170,9 +6170,9 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
break;
|
||||
case ICmpInst::ICMP_UGT:
|
||||
if (Op0Min.ugt(Op1Max)) // A >u B -> true if min(A) > max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Max.ule(Op1Min)) // A >u B -> false if max(A) <= max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
|
||||
if (Op1Max == Op0Min) // A >u B -> A != B if min(A) == max(B)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_NE, Op0, Op1);
|
||||
@ -6189,9 +6189,9 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
break;
|
||||
case ICmpInst::ICMP_SLT:
|
||||
if (Op0Max.slt(Op1Min)) // A <s B -> true if max(A) < min(C)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Min.sge(Op1Max)) // A <s B -> false if min(A) >= max(C)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
if (Op1Min == Op0Max) // A <s B -> A != B if max(A) == min(B)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_NE, Op0, Op1);
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
|
||||
@ -6202,9 +6202,9 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
break;
|
||||
case ICmpInst::ICMP_SGT:
|
||||
if (Op0Min.sgt(Op1Max)) // A >s B -> true if min(A) > max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Max.sle(Op1Min)) // A >s B -> false if max(A) <= min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
|
||||
if (Op1Max == Op0Min) // A >s B -> A != B if min(A) == max(B)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_NE, Op0, Op1);
|
||||
@ -6217,30 +6217,30 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
|
||||
case ICmpInst::ICMP_SGE:
|
||||
assert(!isa<ConstantInt>(Op1) && "ICMP_SGE with ConstantInt not folded!");
|
||||
if (Op0Min.sge(Op1Max)) // A >=s B -> true if min(A) >= max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Max.slt(Op1Min)) // A >=s B -> false if max(A) < min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_SLE:
|
||||
assert(!isa<ConstantInt>(Op1) && "ICMP_SLE with ConstantInt not folded!");
|
||||
if (Op0Max.sle(Op1Min)) // A <=s B -> true if max(A) <= min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Min.sgt(Op1Max)) // A <=s B -> false if min(A) > max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_UGE:
|
||||
assert(!isa<ConstantInt>(Op1) && "ICMP_UGE with ConstantInt not folded!");
|
||||
if (Op0Min.uge(Op1Max)) // A >=u B -> true if min(A) >= max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Max.ult(Op1Min)) // A >=u B -> false if max(A) < min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
case ICmpInst::ICMP_ULE:
|
||||
assert(!isa<ConstantInt>(Op1) && "ICMP_ULE with ConstantInt not folded!");
|
||||
if (Op0Max.ule(Op1Min)) // A <=u B -> true if max(A) <= min(B)
|
||||
return ReplaceInstUsesWith(I, Context->getTrue());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getTrue(*Context));
|
||||
if (Op0Min.ugt(Op1Max)) // A <=u B -> false if min(A) > max(B)
|
||||
return ReplaceInstUsesWith(I, Context->getFalse());
|
||||
return ReplaceInstUsesWith(I, ConstantInt::getFalse(*Context));
|
||||
break;
|
||||
}
|
||||
|
||||
@ -6653,7 +6653,7 @@ Instruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI,
|
||||
default: llvm_unreachable("Unhandled icmp opcode!");
|
||||
case ICmpInst::ICMP_EQ:
|
||||
if (LoOverflow && HiOverflow)
|
||||
return ReplaceInstUsesWith(ICI, Context->getFalse());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(*Context));
|
||||
else if (HiOverflow)
|
||||
return new ICmpInst(*Context, DivIsSigned ? ICmpInst::ICMP_SGE :
|
||||
ICmpInst::ICMP_UGE, X, LoBound);
|
||||
@ -6664,7 +6664,7 @@ Instruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI,
|
||||
return InsertRangeTest(X, LoBound, HiBound, DivIsSigned, true, ICI);
|
||||
case ICmpInst::ICMP_NE:
|
||||
if (LoOverflow && HiOverflow)
|
||||
return ReplaceInstUsesWith(ICI, Context->getTrue());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(*Context));
|
||||
else if (HiOverflow)
|
||||
return new ICmpInst(*Context, DivIsSigned ? ICmpInst::ICMP_SLT :
|
||||
ICmpInst::ICMP_ULT, X, LoBound);
|
||||
@ -6676,16 +6676,16 @@ Instruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI,
|
||||
case ICmpInst::ICMP_ULT:
|
||||
case ICmpInst::ICMP_SLT:
|
||||
if (LoOverflow == +1) // Low bound is greater than input range.
|
||||
return ReplaceInstUsesWith(ICI, Context->getTrue());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(*Context));
|
||||
if (LoOverflow == -1) // Low bound is less than input range.
|
||||
return ReplaceInstUsesWith(ICI, Context->getFalse());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(*Context));
|
||||
return new ICmpInst(*Context, Pred, X, LoBound);
|
||||
case ICmpInst::ICMP_UGT:
|
||||
case ICmpInst::ICMP_SGT:
|
||||
if (HiOverflow == +1) // High bound greater than input range.
|
||||
return ReplaceInstUsesWith(ICI, Context->getFalse());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(*Context));
|
||||
else if (HiOverflow == -1) // High bound less than input range.
|
||||
return ReplaceInstUsesWith(ICI, Context->getTrue());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(*Context));
|
||||
if (Pred == ICmpInst::ICMP_UGT)
|
||||
return new ICmpInst(*Context, ICmpInst::ICMP_UGE, X, HiBound);
|
||||
else
|
||||
@ -6854,9 +6854,9 @@ Instruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI,
|
||||
// As a special case, check to see if this means that the
|
||||
// result is always true or false now.
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
|
||||
return ReplaceInstUsesWith(ICI, Context->getFalse());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(*Context));
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_NE)
|
||||
return ReplaceInstUsesWith(ICI, Context->getTrue());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(*Context));
|
||||
} else {
|
||||
ICI.setOperand(1, NewCst);
|
||||
Constant *NewAndCST;
|
||||
@ -7277,9 +7277,9 @@ Instruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) {
|
||||
// First, handle some easy cases. We know the result cannot be equal at this
|
||||
// point so handle the ICI.isEquality() cases
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
|
||||
return ReplaceInstUsesWith(ICI, Context->getFalse());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(*Context));
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_NE)
|
||||
return ReplaceInstUsesWith(ICI, Context->getTrue());
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(*Context));
|
||||
|
||||
// Evaluate the comparison for LT (we invert for GT below). LE and GE cases
|
||||
// should have been folded away previously and not enter in here.
|
||||
@ -7287,9 +7287,9 @@ Instruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) {
|
||||
if (isSignedCmp) {
|
||||
// We're performing a signed comparison.
|
||||
if (cast<ConstantInt>(CI)->getValue().isNegative())
|
||||
Result = Context->getFalse(); // X < (small) --> false
|
||||
Result = ConstantInt::getFalse(*Context); // X < (small) --> false
|
||||
else
|
||||
Result = Context->getTrue(); // X < (large) --> true
|
||||
Result = ConstantInt::getTrue(*Context); // X < (large) --> true
|
||||
} else {
|
||||
// We're performing an unsigned comparison.
|
||||
if (isSignedExt) {
|
||||
@ -7300,7 +7300,7 @@ Instruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) {
|
||||
LHSCIOp, NegOne, ICI.getName()), ICI);
|
||||
} else {
|
||||
// Unsigned extend & unsigned compare -> always true.
|
||||
Result = Context->getTrue();
|
||||
Result = ConstantInt::getTrue(*Context);
|
||||
}
|
||||
}
|
||||
|
||||
@ -8441,7 +8441,7 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
|
||||
// cast (xor bool X, true) to int --> xor (cast bool X to int), 1
|
||||
if (isa<ZExtInst>(CI) && SrcBitSize == 1 &&
|
||||
SrcI->getOpcode() == Instruction::Xor &&
|
||||
Op1 == Context->getTrue() &&
|
||||
Op1 == ConstantInt::getTrue(*Context) &&
|
||||
(!Op0->hasOneUse() || !isa<CmpInst>(Op0))) {
|
||||
Value *New = InsertCastBefore(Instruction::ZExt, Op0, DestTy, CI);
|
||||
return BinaryOperator::CreateXor(New,
|
||||
@ -10061,7 +10061,7 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
|
||||
Instruction *OldCall = CS.getInstruction();
|
||||
// If the call and callee calling conventions don't match, this call must
|
||||
// be unreachable, as the call is undefined.
|
||||
new StoreInst(Context->getTrue(),
|
||||
new StoreInst(ConstantInt::getTrue(*Context),
|
||||
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
|
||||
OldCall);
|
||||
if (!OldCall->use_empty())
|
||||
@ -10075,7 +10075,7 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
|
||||
// This instruction is not reachable, just remove it. We insert a store to
|
||||
// undef so that we know that this code is not reachable, despite the fact
|
||||
// that we can't modify the CFG here.
|
||||
new StoreInst(Context->getTrue(),
|
||||
new StoreInst(ConstantInt::getTrue(*Context),
|
||||
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
|
||||
CS.getInstruction());
|
||||
|
||||
@ -10086,7 +10086,7 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
|
||||
if (InvokeInst *II = dyn_cast<InvokeInst>(CS.getInstruction())) {
|
||||
// Don't break the CFG, insert a dummy cond branch.
|
||||
BranchInst::Create(II->getNormalDest(), II->getUnwindDest(),
|
||||
Context->getTrue(), II);
|
||||
ConstantInt::getTrue(*Context), II);
|
||||
}
|
||||
return EraseInstFromFunction(*CS.getInstruction());
|
||||
}
|
||||
@ -11425,7 +11425,7 @@ Instruction *InstCombiner::visitFreeInst(FreeInst &FI) {
|
||||
// free undef -> unreachable.
|
||||
if (isa<UndefValue>(Op)) {
|
||||
// Insert a new store to null because we cannot modify the CFG here.
|
||||
new StoreInst(Context->getTrue(),
|
||||
new StoreInst(ConstantInt::getTrue(*Context),
|
||||
UndefValue::get(PointerType::getUnqual(Type::Int1Ty)), &FI);
|
||||
return EraseInstFromFunction(FI);
|
||||
}
|
||||
|
@ -718,7 +718,8 @@ bool JumpThreading::ProcessJumpOnPHI(PHINode *PN) {
|
||||
// Next, figure out which successor we are threading to.
|
||||
BasicBlock *SuccBB;
|
||||
if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator()))
|
||||
SuccBB = BI->getSuccessor(PredCst == PredBB->getContext().getFalse());
|
||||
SuccBB = BI->getSuccessor(PredCst ==
|
||||
ConstantInt::getFalse(PredBB->getContext()));
|
||||
else {
|
||||
SwitchInst *SI = cast<SwitchInst>(BB->getTerminator());
|
||||
SuccBB = SI->getSuccessor(SI->findCaseValue(PredCst));
|
||||
@ -803,7 +804,7 @@ static Constant *GetResultOfComparison(CmpInst::Predicate pred,
|
||||
if (LHS == RHS)
|
||||
if (isa<IntegerType>(LHS->getType()) || isa<PointerType>(LHS->getType()))
|
||||
return ICmpInst::isTrueWhenEqual(pred) ?
|
||||
Context.getTrue() : Context.getFalse();
|
||||
ConstantInt::getTrue(Context) : ConstantInt::getFalse(Context);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -235,7 +235,7 @@ bool LoopUnswitch::processCurrentLoop() {
|
||||
Value *LoopCond = FindLIVLoopCondition(BI->getCondition(),
|
||||
currentLoop, Changed);
|
||||
if (LoopCond && UnswitchIfProfitable(LoopCond,
|
||||
Context.getTrue())) {
|
||||
ConstantInt::getTrue(Context))) {
|
||||
++NumBranches;
|
||||
return true;
|
||||
}
|
||||
@ -265,7 +265,7 @@ bool LoopUnswitch::processCurrentLoop() {
|
||||
Value *LoopCond = FindLIVLoopCondition(SI->getCondition(),
|
||||
currentLoop, Changed);
|
||||
if (LoopCond && UnswitchIfProfitable(LoopCond,
|
||||
Context.getTrue())) {
|
||||
ConstantInt::getTrue(Context))) {
|
||||
++NumSelects;
|
||||
return true;
|
||||
}
|
||||
@ -354,10 +354,10 @@ bool LoopUnswitch::IsTrivialUnswitchCondition(Value *Cond, Constant **Val,
|
||||
// this.
|
||||
if ((LoopExitBB = isTrivialLoopExitBlock(currentLoop,
|
||||
BI->getSuccessor(0)))) {
|
||||
if (Val) *Val = Context.getTrue();
|
||||
if (Val) *Val = ConstantInt::getTrue(Context);
|
||||
} else if ((LoopExitBB = isTrivialLoopExitBlock(currentLoop,
|
||||
BI->getSuccessor(1)))) {
|
||||
if (Val) *Val = Context.getFalse();
|
||||
if (Val) *Val = ConstantInt::getFalse(Context);
|
||||
}
|
||||
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(HeaderTerm)) {
|
||||
// If this isn't a switch on Cond, we can't handle it.
|
||||
@ -513,7 +513,7 @@ void LoopUnswitch::EmitPreheaderBranchOnCondition(Value *LIC, Constant *Val,
|
||||
Value *BranchVal = LIC;
|
||||
if (!isa<ConstantInt>(Val) || Val->getType() != Type::Int1Ty)
|
||||
BranchVal = new ICmpInst(InsertPt, ICmpInst::ICMP_EQ, LIC, Val, "tmp");
|
||||
else if (Val != Val->getContext().getTrue())
|
||||
else if (Val != ConstantInt::getTrue(Val->getContext()))
|
||||
// We want to enter the new loop when the condition is true.
|
||||
std::swap(TrueDest, FalseDest);
|
||||
|
||||
@ -952,7 +952,7 @@ void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
|
||||
|
||||
Instruction* OldTerm = Old->getTerminator();
|
||||
BranchInst::Create(Split, SISucc,
|
||||
Context.getTrue(), OldTerm);
|
||||
ConstantInt::getTrue(Context), OldTerm);
|
||||
|
||||
LPM->deleteSimpleAnalysisValue(Old->getTerminator(), L);
|
||||
Old->getTerminator()->eraseFromParent();
|
||||
|
@ -1695,7 +1695,7 @@ namespace {
|
||||
if (Constant *C1 = dyn_cast<Constant>(V1))
|
||||
if (Constant *C2 = dyn_cast<Constant>(V2))
|
||||
return ConstantExpr::getCompare(Pred, C1, C2) ==
|
||||
Context->getTrue();
|
||||
ConstantInt::getTrue(*Context);
|
||||
|
||||
unsigned n1 = VN.valueNumber(V1, Top);
|
||||
unsigned n2 = VN.valueNumber(V2, Top);
|
||||
@ -1807,10 +1807,10 @@ namespace {
|
||||
// "icmp ult i32 %a, %y" EQ true then %a u< y
|
||||
// etc.
|
||||
|
||||
if (Canonical == Context->getTrue()) {
|
||||
if (Canonical == ConstantInt::getTrue(*Context)) {
|
||||
add(IC->getOperand(0), IC->getOperand(1), IC->getPredicate(),
|
||||
NewContext);
|
||||
} else if (Canonical == Context->getFalse()) {
|
||||
} else if (Canonical == ConstantInt::getFalse(*Context)) {
|
||||
add(IC->getOperand(0), IC->getOperand(1),
|
||||
ICmpInst::getInversePredicate(IC->getPredicate()), NewContext);
|
||||
}
|
||||
@ -1826,11 +1826,11 @@ namespace {
|
||||
if (isRelatedBy(True, False, ICmpInst::ICMP_NE)) {
|
||||
if (Canonical == VN.canonicalize(True, Top) ||
|
||||
isRelatedBy(Canonical, False, ICmpInst::ICMP_NE))
|
||||
add(SI->getCondition(), Context->getTrue(),
|
||||
add(SI->getCondition(), ConstantInt::getTrue(*Context),
|
||||
ICmpInst::ICMP_EQ, NewContext);
|
||||
else if (Canonical == VN.canonicalize(False, Top) ||
|
||||
isRelatedBy(Canonical, True, ICmpInst::ICMP_NE))
|
||||
add(SI->getCondition(), Context->getFalse(),
|
||||
add(SI->getCondition(), ConstantInt::getFalse(*Context),
|
||||
ICmpInst::ICMP_EQ, NewContext);
|
||||
}
|
||||
} else if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) {
|
||||
@ -2054,9 +2054,9 @@ namespace {
|
||||
|
||||
ICmpInst::Predicate Pred = IC->getPredicate();
|
||||
if (isRelatedBy(Op0, Op1, Pred))
|
||||
add(IC, Context->getTrue(), ICmpInst::ICMP_EQ, NewContext);
|
||||
add(IC, ConstantInt::getTrue(*Context), ICmpInst::ICMP_EQ, NewContext);
|
||||
else if (isRelatedBy(Op0, Op1, ICmpInst::getInversePredicate(Pred)))
|
||||
add(IC, Context->getFalse(),
|
||||
add(IC, ConstantInt::getFalse(*Context),
|
||||
ICmpInst::ICMP_EQ, NewContext);
|
||||
|
||||
} else if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
|
||||
@ -2068,9 +2068,9 @@ namespace {
|
||||
// %b EQ %c then %a EQ %b
|
||||
|
||||
Value *Canonical = VN.canonicalize(SI->getCondition(), Top);
|
||||
if (Canonical == Context->getTrue()) {
|
||||
if (Canonical == ConstantInt::getTrue(*Context)) {
|
||||
add(SI, SI->getTrueValue(), ICmpInst::ICMP_EQ, NewContext);
|
||||
} else if (Canonical == Context->getFalse()) {
|
||||
} else if (Canonical == ConstantInt::getFalse(*Context)) {
|
||||
add(SI, SI->getFalseValue(), ICmpInst::ICMP_EQ, NewContext);
|
||||
} else if (VN.canonicalize(SI->getTrueValue(), Top) ==
|
||||
VN.canonicalize(SI->getFalseValue(), Top)) {
|
||||
@ -2162,7 +2162,7 @@ namespace {
|
||||
if (Constant *CI_L = dyn_cast<Constant>(O.LHS)) {
|
||||
if (Constant *CI_R = dyn_cast<Constant>(O.RHS)) {
|
||||
if (ConstantExpr::getCompare(O.Op, CI_L, CI_R) ==
|
||||
Context->getFalse())
|
||||
ConstantInt::getFalse(*Context))
|
||||
UB.mark(TopBB);
|
||||
|
||||
WorkList.pop_front();
|
||||
@ -2467,7 +2467,7 @@ namespace {
|
||||
DEBUG(errs() << "(" << DTNode->getBlock()->getName()
|
||||
<< ") true set:\n");
|
||||
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, Dest);
|
||||
VRP.add(Context->getTrue(), Condition, ICmpInst::ICMP_EQ);
|
||||
VRP.add(ConstantInt::getTrue(*Context), Condition, ICmpInst::ICMP_EQ);
|
||||
VRP.solve();
|
||||
DEBUG(VN.dump());
|
||||
DEBUG(IG.dump());
|
||||
@ -2476,7 +2476,7 @@ namespace {
|
||||
DEBUG(errs() << "(" << DTNode->getBlock()->getName()
|
||||
<< ") false set:\n");
|
||||
VRPSolver VRP(VN, IG, UB, VR, PS->DTDFS, PS->modified, Dest);
|
||||
VRP.add(Context->getFalse(), Condition, ICmpInst::ICMP_EQ);
|
||||
VRP.add(ConstantInt::getFalse(*Context), Condition, ICmpInst::ICMP_EQ);
|
||||
VRP.solve();
|
||||
DEBUG(VN.dump());
|
||||
DEBUG(IG.dump());
|
||||
|
@ -442,7 +442,7 @@ void SCCPSolver::getFeasibleSuccessors(TerminatorInst &TI,
|
||||
Succs[0] = Succs[1] = true;
|
||||
} else if (BCValue.isConstant()) {
|
||||
// Constant condition variables mean the branch can only go a single way
|
||||
Succs[BCValue.getConstant() == Context->getFalse()] = true;
|
||||
Succs[BCValue.getConstant() == ConstantInt::getFalse(*Context)] = true;
|
||||
}
|
||||
}
|
||||
} else if (isa<InvokeInst>(&TI)) {
|
||||
@ -487,7 +487,7 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
|
||||
|
||||
// Constant condition variables mean the branch can only go a single way
|
||||
return BI->getSuccessor(BCValue.getConstant() ==
|
||||
Context->getFalse()) == To;
|
||||
ConstantInt::getFalse(*Context)) == To;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -1488,7 +1488,7 @@ bool SCCPSolver::ResolvedUndefsIn(Function &F) {
|
||||
// as undef, then further analysis could think the undef went another way
|
||||
// leading to an inconsistent set of conclusions.
|
||||
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
|
||||
BI->setCondition(Context->getFalse());
|
||||
BI->setCondition(ConstantInt::getFalse(*Context));
|
||||
} else {
|
||||
SwitchInst *SI = cast<SwitchInst>(TI);
|
||||
SI->setCondition(SI->getCaseValue(1));
|
||||
|
@ -1398,9 +1398,9 @@ Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
|
||||
// Don't try to evaluate aliases. External weak GV can be null.
|
||||
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
|
||||
if (pred == ICmpInst::ICMP_EQ)
|
||||
return Context.getFalse();
|
||||
return ConstantInt::getFalse(Context);
|
||||
else if (pred == ICmpInst::ICMP_NE)
|
||||
return Context.getTrue();
|
||||
return ConstantInt::getTrue(Context);
|
||||
}
|
||||
// icmp eq/ne(GV,null) -> false/true
|
||||
} else if (C2->isNullValue()) {
|
||||
@ -1408,9 +1408,9 @@ Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
|
||||
// Don't try to evaluate aliases. External weak GV can be null.
|
||||
if (!isa<GlobalAlias>(GV) && !GV->hasExternalWeakLinkage()) {
|
||||
if (pred == ICmpInst::ICMP_EQ)
|
||||
return Context.getFalse();
|
||||
return ConstantInt::getFalse(Context);
|
||||
else if (pred == ICmpInst::ICMP_NE)
|
||||
return Context.getTrue();
|
||||
return ConstantInt::getTrue(Context);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1446,8 +1446,8 @@ Constant *llvm::ConstantFoldCompareInstruction(LLVMContext &Context,
|
||||
APFloat::cmpResult R = C1V.compare(C2V);
|
||||
switch (pred) {
|
||||
default: llvm_unreachable("Invalid FCmp Predicate"); return 0;
|
||||
case FCmpInst::FCMP_FALSE: return Context.getFalse();
|
||||
case FCmpInst::FCMP_TRUE: return Context.getTrue();
|
||||
case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse(Context);
|
||||
case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue(Context);
|
||||
case FCmpInst::FCMP_UNO:
|
||||
return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered);
|
||||
case FCmpInst::FCMP_ORD:
|
||||
|
@ -171,6 +171,25 @@ ConstantInt::ConstantInt(const IntegerType *Ty, const APInt& V)
|
||||
assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type");
|
||||
}
|
||||
|
||||
ConstantInt* ConstantInt::getTrue(LLVMContext &Context) {
|
||||
LLVMContextImpl *pImpl = Context.pImpl;
|
||||
sys::SmartScopedWriter<true>(pImpl->ConstantsLock);
|
||||
if (pImpl->TheTrueVal)
|
||||
return pImpl->TheTrueVal;
|
||||
else
|
||||
return (pImpl->TheTrueVal = ConstantInt::get(IntegerType::get(1), 1));
|
||||
}
|
||||
|
||||
ConstantInt* ConstantInt::getFalse(LLVMContext &Context) {
|
||||
LLVMContextImpl *pImpl = Context.pImpl;
|
||||
sys::SmartScopedWriter<true>(pImpl->ConstantsLock);
|
||||
if (pImpl->TheFalseVal)
|
||||
return pImpl->TheFalseVal;
|
||||
else
|
||||
return (pImpl->TheFalseVal = ConstantInt::get(IntegerType::get(1), 0));
|
||||
}
|
||||
|
||||
|
||||
// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap
|
||||
// as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the
|
||||
// operator== and operator!= to ensure that the DenseMap doesn't attempt to
|
||||
@ -1386,8 +1405,7 @@ static inline Constant *getFoldedCast(
|
||||
Instruction::CastOps opc, Constant *C, const Type *Ty) {
|
||||
assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");
|
||||
// Fold a few common cases
|
||||
if (Constant *FC =
|
||||
ConstantFoldCastInstruction(getGlobalContext(), opc, C, Ty))
|
||||
if (Constant *FC = ConstantFoldCastInstruction(Ty->getContext(), opc, C, Ty))
|
||||
return FC;
|
||||
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
@ -1631,8 +1649,8 @@ Constant *ConstantExpr::getTy(const Type *ReqTy, unsigned Opcode,
|
||||
"Operand types in binary constant expression should match");
|
||||
|
||||
if (ReqTy == C1->getType() || ReqTy == Type::Int1Ty)
|
||||
if (Constant *FC = ConstantFoldBinaryInstruction(
|
||||
getGlobalContext(), Opcode, C1, C2))
|
||||
if (Constant *FC = ConstantFoldBinaryInstruction(ReqTy->getContext(),
|
||||
Opcode, C1, C2))
|
||||
return FC; // Fold a few common cases...
|
||||
|
||||
std::vector<Constant*> argVec(1, C1); argVec.push_back(C2);
|
||||
@ -1765,7 +1783,7 @@ Constant *ConstantExpr::getSelectTy(const Type *ReqTy, Constant *C,
|
||||
|
||||
if (ReqTy == V1->getType())
|
||||
if (Constant *SC = ConstantFoldSelectInstruction(
|
||||
getGlobalContext(), C, V1, V2))
|
||||
ReqTy->getContext(), C, V1, V2))
|
||||
return SC; // Fold common cases
|
||||
|
||||
std::vector<Constant*> argVec(3, C);
|
||||
@ -1786,7 +1804,7 @@ Constant *ConstantExpr::getGetElementPtrTy(const Type *ReqTy, Constant *C,
|
||||
"GEP indices invalid!");
|
||||
|
||||
if (Constant *FC = ConstantFoldGetElementPtr(
|
||||
getGlobalContext(), C, (Constant**)Idxs, NumIdx))
|
||||
ReqTy->getContext(), C, (Constant**)Idxs, NumIdx))
|
||||
return FC; // Fold a few common cases...
|
||||
|
||||
assert(isa<PointerType>(C->getType()) &&
|
||||
@ -1826,7 +1844,7 @@ ConstantExpr::getICmp(unsigned short pred, Constant* LHS, Constant* RHS) {
|
||||
pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate");
|
||||
|
||||
if (Constant *FC = ConstantFoldCompareInstruction(
|
||||
getGlobalContext(),pred, LHS, RHS))
|
||||
LHS->getContext(), pred, LHS, RHS))
|
||||
return FC; // Fold a few common cases...
|
||||
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
@ -1846,7 +1864,7 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) {
|
||||
assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate");
|
||||
|
||||
if (Constant *FC = ConstantFoldCompareInstruction(
|
||||
getGlobalContext(), pred, LHS, RHS))
|
||||
LHS->getContext(), pred, LHS, RHS))
|
||||
return FC; // Fold a few common cases...
|
||||
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
@ -1863,7 +1881,7 @@ ConstantExpr::getFCmp(unsigned short pred, Constant* LHS, Constant* RHS) {
|
||||
Constant *ConstantExpr::getExtractElementTy(const Type *ReqTy, Constant *Val,
|
||||
Constant *Idx) {
|
||||
if (Constant *FC = ConstantFoldExtractElementInstruction(
|
||||
getGlobalContext(), Val, Idx))
|
||||
ReqTy->getContext(), Val, Idx))
|
||||
return FC; // Fold a few common cases...
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
std::vector<Constant*> ArgVec(1, Val);
|
||||
@ -1886,7 +1904,7 @@ Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) {
|
||||
Constant *ConstantExpr::getInsertElementTy(const Type *ReqTy, Constant *Val,
|
||||
Constant *Elt, Constant *Idx) {
|
||||
if (Constant *FC = ConstantFoldInsertElementInstruction(
|
||||
getGlobalContext(), Val, Elt, Idx))
|
||||
ReqTy->getContext(), Val, Elt, Idx))
|
||||
return FC; // Fold a few common cases...
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
std::vector<Constant*> ArgVec(1, Val);
|
||||
@ -1912,7 +1930,7 @@ Constant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt,
|
||||
Constant *ConstantExpr::getShuffleVectorTy(const Type *ReqTy, Constant *V1,
|
||||
Constant *V2, Constant *Mask) {
|
||||
if (Constant *FC = ConstantFoldShuffleVectorInstruction(
|
||||
getGlobalContext(), V1, V2, Mask))
|
||||
ReqTy->getContext(), V1, V2, Mask))
|
||||
return FC; // Fold a few common cases...
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
std::vector<Constant*> ArgVec(1, V1);
|
||||
@ -1946,7 +1964,7 @@ Constant *ConstantExpr::getInsertValueTy(const Type *ReqTy, Constant *Agg,
|
||||
assert(Agg->getType()->isFirstClassType() &&
|
||||
"Non-first-class type for constant InsertValue expression");
|
||||
Constant *FC = ConstantFoldInsertValueInstruction(
|
||||
getGlobalContext(), Agg, Val, Idxs, NumIdx);
|
||||
ReqTy->getContext(), Agg, Val, Idxs, NumIdx);
|
||||
assert(FC && "InsertValue constant expr couldn't be folded!");
|
||||
return FC;
|
||||
}
|
||||
@ -1973,7 +1991,7 @@ Constant *ConstantExpr::getExtractValueTy(const Type *ReqTy, Constant *Agg,
|
||||
assert(Agg->getType()->isFirstClassType() &&
|
||||
"Non-first-class type for constant extractvalue expression");
|
||||
Constant *FC = ConstantFoldExtractValueInstruction(
|
||||
getGlobalContext(), Agg, Idxs, NumIdx);
|
||||
ReqTy->getContext(), Agg, Idxs, NumIdx);
|
||||
assert(FC && "ExtractValue constant expr couldn't be folded!");
|
||||
return FC;
|
||||
}
|
||||
|
@ -75,19 +75,6 @@ Constant* LLVMContext::getAllOnesValue(const Type* Ty) {
|
||||
return cast<ConstantVector>(ConstantVector::get(Elts));
|
||||
}
|
||||
|
||||
// ConstantInt accessors.
|
||||
ConstantInt* LLVMContext::getTrue() {
|
||||
assert(this && "Context not initialized!");
|
||||
assert(pImpl && "Context not initialized!");
|
||||
return pImpl->getTrue();
|
||||
}
|
||||
|
||||
ConstantInt* LLVMContext::getFalse() {
|
||||
assert(this && "Context not initialized!");
|
||||
assert(pImpl && "Context not initialized!");
|
||||
return pImpl->getFalse();
|
||||
}
|
||||
|
||||
// MDNode accessors
|
||||
MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) {
|
||||
return pImpl->getMDNode(Vals, NumVals);
|
||||
|
@ -469,20 +469,6 @@ public:
|
||||
|
||||
MDNode *getMDNode(Value*const* Vals, unsigned NumVals);
|
||||
|
||||
ConstantInt *getTrue() {
|
||||
if (TheTrueVal)
|
||||
return TheTrueVal;
|
||||
else
|
||||
return (TheTrueVal = ConstantInt::get(IntegerType::get(1), 1));
|
||||
}
|
||||
|
||||
ConstantInt *getFalse() {
|
||||
if (TheFalseVal)
|
||||
return TheFalseVal;
|
||||
else
|
||||
return (TheFalseVal = ConstantInt::get(IntegerType::get(1), 0));
|
||||
}
|
||||
|
||||
void erase(MDString *M);
|
||||
void erase(MDNode *M);
|
||||
};
|
||||
|
Loading…
Reference in New Issue
Block a user