Implement review feedback for the ConstantBool->ConstantInt merge. Chris
recommended that getBoolValue be replaced with getZExtValue and that
get(bool) be replaced by get(const Type*, uint64_t). This implements
those changes.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33110 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/include/llvm/Constants.h b/include/llvm/Constants.h
index 337a62c..dd85b43 100644
--- a/include/llvm/Constants.h
+++ b/include/llvm/Constants.h
@@ -85,10 +85,6 @@
return F = new ConstantInt(false);
}
- /// @brief Static factory method for getting a ConstantInt instance which
- /// stands for a bool value.
- static ConstantInt *get(bool Value) { return Value ? getTrue() : getFalse();}
-
/// Return a ConstantInt with the specified value for the specified type. The
/// value V will be canonicalized to a uint64_t but accessing it with either
/// getSExtValue() or getZExtValue() (ConstantInt) will yield the correct
@@ -96,22 +92,6 @@
/// @brief Get a ConstantInt for a specific value.
static ConstantInt *get(const Type *Ty, int64_t V);
- /// Returns the opposite value of this ConstantInt.
- /// @brief Get inverse value.
- inline ConstantInt *inverted() const {
- static ConstantInt *CI = 0;
- if (CI) return CI;
- return CI = new ConstantInt(getType(),
- Val ^ (getType() == Type::Int1Ty ? 1 : -1));
- }
-
- /// @returns the value of this ConstantInt only if it's a boolean type.
- /// @brief return the boolean value of this constant.
- inline bool getBoolValue() const {
- assert(getType() == Type::Int1Ty && "Should be a boolean constant!");
- return static_cast<bool>(getZExtValue());
- }
-
/// This static method returns true if the type Ty is big enough to
/// represent the value V. This can be used to avoid having the get method
/// assert when V is larger than Ty can represent. Note that there are two
@@ -136,8 +116,7 @@
/// to true.
/// @returns true iff this constant's bits are all set to true.
/// @brief Determine if the value is all ones.
- virtual bool isAllOnesValue() const {
- if (getType() == Type::Int1Ty) return getBoolValue() == true;
+ bool isAllOnesValue() const {
return getSExtValue() == -1;
}
@@ -146,8 +125,7 @@
/// @returns true iff this is the largest value that may be represented
/// by this type.
/// @brief Determine if the value is maximal.
- virtual bool isMaxValue(bool isSigned) const {
- if (getType() == Type::Int1Ty) return getBoolValue() == true;
+ bool isMaxValue(bool isSigned) const {
if (isSigned) {
int64_t V = getSExtValue();
if (V < 0) return false; // Be careful about wrap-around on 'long's
@@ -162,8 +140,7 @@
/// @returns true if this is the smallest value that may be represented by
/// this type.
/// @brief Determine if the value is minimal.
- virtual bool isMinValue(bool isSigned) const {
- if (getType() == Type::Int1Ty) return getBoolValue() == false;
+ bool isMinValue(bool isSigned) const {
if (isSigned) {
int64_t V = getSExtValue();
if (V > 0) return false; // Be careful about wrap-around on 'long's
diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp
index ebe4cec..d49898a 100644
--- a/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/lib/Analysis/BasicAliasAnalysis.cpp
@@ -586,7 +586,7 @@
Constant *Compare = ConstantExpr::getICmp(ICmpInst::ICMP_SGT,
G1OC, G2OC);
if (ConstantInt *CV = dyn_cast<ConstantInt>(Compare)) {
- if (CV->getBoolValue()) // If they are comparable and G2 > G1
+ if (CV->getZExtValue()) // If they are comparable and G2 > G1
std::swap(GEP1Ops, GEP2Ops); // Make GEP1 < GEP2
break;
}
diff --git a/lib/Analysis/ConstantRange.cpp b/lib/Analysis/ConstantRange.cpp
index 6c2dce0..7a34420 100644
--- a/lib/Analysis/ConstantRange.cpp
+++ b/lib/Analysis/ConstantRange.cpp
@@ -64,7 +64,7 @@
}
static ConstantInt *Next(ConstantInt *CI) {
if (CI->getType() == Type::Int1Ty)
- return ConstantInt::get(!CI->getBoolValue());
+ return ConstantInt::get(Type::Int1Ty, !CI->getZExtValue());
Constant *Result = ConstantExpr::getAdd(CI,
ConstantInt::get(CI->getType(), 1));
@@ -75,14 +75,14 @@
Constant *C = ConstantExpr::getICmp(
(isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT), A, B);
assert(isa<ConstantInt>(C) && "Constant folding of integrals not impl??");
- return cast<ConstantInt>(C)->getBoolValue();
+ return cast<ConstantInt>(C)->getZExtValue();
}
static bool LTE(ConstantInt *A, ConstantInt *B, bool isSigned) {
Constant *C = ConstantExpr::getICmp(
(isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE), A, B);
assert(isa<ConstantInt>(C) && "Constant folding of integrals not impl??");
- return cast<ConstantInt>(C)->getBoolValue();
+ return cast<ConstantInt>(C)->getZExtValue();
}
static bool GT(ConstantInt *A, ConstantInt *B, bool isSigned) {
diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index ad16acc..27c9e62 100644
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -1722,7 +1722,7 @@
// Evaluate the condition for this iteration.
Result = ConstantExpr::getICmp(predicate, Result, RHS);
if (!isa<ConstantInt>(Result)) break; // Couldn't decide for sure
- if (cast<ConstantInt>(Result)->getBoolValue() == false) {
+ if (cast<ConstantInt>(Result)->getZExtValue() == false) {
#if 0
cerr << "\n***\n*** Computed loop count " << *ItCst
<< "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
@@ -1932,7 +1932,7 @@
// Couldn't symbolically evaluate.
if (!CondVal || CondVal->getType() != Type::Int1Ty) return UnknownValue;
- if (CondVal->getBoolValue() == ExitWhen) {
+ if (CondVal->getZExtValue() == ExitWhen) {
ConstantEvolutionLoopExitValue[PN] = PHIVal;
++NumBruteForceTripCountsComputed;
return SCEVConstant::get(ConstantInt::get(Type::Int32Ty, IterationNum));
@@ -2204,7 +2204,7 @@
if (ConstantInt *CB =
dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
R1->getValue(), R2->getValue()))) {
- if (CB->getBoolValue() == false)
+ if (CB->getZExtValue() == false)
std::swap(R1, R2); // R1 is the minimum root now.
// We can only use this value if the chrec ends up with an exact zero
@@ -2429,7 +2429,7 @@
if (ConstantInt *CB =
dyn_cast<ConstantInt>(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
R1->getValue(), R2->getValue()))) {
- if (CB->getBoolValue() == false)
+ if (CB->getZExtValue() == false)
std::swap(R1, R2); // R1 is the minimum root now.
// Make sure the root is not off by one. The returned iteration should
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index b3869fb..787d000 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -1403,7 +1403,7 @@
unsigned Val = read_vbr_uint();
if (Val != 0 && Val != 1)
error("Invalid boolean value read.");
- Result = ConstantInt::get(Val == 1);
+ Result = ConstantInt::get(Type::Int1Ty, Val == 1);
if (Handler) Handler->handleConstantValue(Result);
break;
}
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 7acd209..9a04428 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -322,7 +322,7 @@
switch (CPV->getType()->getTypeID()) {
case Type::Int1TyID: // Boolean Types
- if (cast<ConstantInt>(CPV)->getBoolValue())
+ if (cast<ConstantInt>(CPV)->getZExtValue())
output_vbr(1U);
else
output_vbr(0U);
diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp
index fed85b3..d7a134e 100644
--- a/lib/CodeGen/AsmPrinter.cpp
+++ b/lib/CodeGen/AsmPrinter.cpp
@@ -390,7 +390,7 @@
O << "0";
else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
if (CI->getType() == Type::Int1Ty) {
- assert(CI->getBoolValue());
+ assert(CI->getZExtValue());
O << "1";
} else O << CI->getSExtValue();
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
diff --git a/lib/CodeGen/MachineDebugInfo.cpp b/lib/CodeGen/MachineDebugInfo.cpp
index 2ebd64b..0a6d3ac 100644
--- a/lib/CodeGen/MachineDebugInfo.cpp
+++ b/lib/CodeGen/MachineDebugInfo.cpp
@@ -211,7 +211,7 @@
}
virtual void Apply(bool &Field) {
Constant *C = CI->getOperand(I++);
- Field = cast<ConstantInt>(C)->getBoolValue();
+ Field = cast<ConstantInt>(C)->getZExtValue();
}
virtual void Apply(std::string &Field) {
Constant *C = CI->getOperand(I++);
@@ -276,7 +276,7 @@
Elements.push_back(ConstantInt::get(Type::Int64Ty, uint64_t(Field)));
}
virtual void Apply(bool &Field) {
- Elements.push_back(ConstantInt::get(Field));
+ Elements.push_back(ConstantInt::get(Type::Int1Ty, Field));
}
virtual void Apply(std::string &Field) {
Elements.push_back(SR.getString(Field));
diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp
index 3c388d3..e5f9ea1 100644
--- a/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -399,7 +399,7 @@
switch (C->getType()->getTypeID()) {
#define GET_CONST_VAL(TY, CTY, CLASS, GETMETH) \
case Type::TY##TyID: Result.TY##Val = (CTY)cast<CLASS>(C)->GETMETH(); break
- GET_CONST_VAL(Int1 , bool , ConstantInt, getBoolValue);
+ GET_CONST_VAL(Int1 , bool , ConstantInt, getZExtValue);
GET_CONST_VAL(Int8 , unsigned char , ConstantInt, getZExtValue);
GET_CONST_VAL(Int16 , unsigned short, ConstantInt, getZExtValue);
GET_CONST_VAL(Int32 , unsigned int , ConstantInt, getZExtValue);
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index f6ced0a..13ee719 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -191,7 +191,7 @@
const GenericValue &AV = ArgValues[i];
switch (ArgTy->getTypeID()) {
default: assert(0 && "Unknown argument type for function call!");
- case Type::Int1TyID: C = ConstantInt::get(AV.Int1Val); break;
+ case Type::Int1TyID: C = ConstantInt::get(ArgTy, AV.Int1Val); break;
case Type::Int8TyID: C = ConstantInt::get(ArgTy, AV.Int8Val); break;
case Type::Int16TyID: C = ConstantInt::get(ArgTy, AV.Int16Val); break;
case Type::Int32TyID: C = ConstantInt::get(ArgTy, AV.Int32Val); break;
diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp
index 6c2dce0..7a34420 100644
--- a/lib/Support/ConstantRange.cpp
+++ b/lib/Support/ConstantRange.cpp
@@ -64,7 +64,7 @@
}
static ConstantInt *Next(ConstantInt *CI) {
if (CI->getType() == Type::Int1Ty)
- return ConstantInt::get(!CI->getBoolValue());
+ return ConstantInt::get(Type::Int1Ty, !CI->getZExtValue());
Constant *Result = ConstantExpr::getAdd(CI,
ConstantInt::get(CI->getType(), 1));
@@ -75,14 +75,14 @@
Constant *C = ConstantExpr::getICmp(
(isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT), A, B);
assert(isa<ConstantInt>(C) && "Constant folding of integrals not impl??");
- return cast<ConstantInt>(C)->getBoolValue();
+ return cast<ConstantInt>(C)->getZExtValue();
}
static bool LTE(ConstantInt *A, ConstantInt *B, bool isSigned) {
Constant *C = ConstantExpr::getICmp(
(isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE), A, B);
assert(isa<ConstantInt>(C) && "Constant folding of integrals not impl??");
- return cast<ConstantInt>(C)->getBoolValue();
+ return cast<ConstantInt>(C)->getZExtValue();
}
static bool GT(ConstantInt *A, ConstantInt *B, bool isSigned) {
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index f945036..23465c5 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -829,7 +829,7 @@
if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
const Type* Ty = CI->getType();
if (Ty == Type::Int1Ty)
- Out << (CI->getBoolValue() ? '1' : '0') ;
+ Out << (CI->getZExtValue() ? '1' : '0') ;
else {
Out << "((";
printPrimitiveType(Out, Ty, false) << ')';
diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index ce30477..86657c2 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1161,7 +1161,7 @@
// Only do this if we weren't storing a loaded value.
Value *StoreVal;
if (StoringOther || SI->getOperand(0) == InitVal)
- StoreVal = ConstantInt::get(StoringOther);
+ StoreVal = ConstantInt::get(Type::Int1Ty, StoringOther);
else {
// Otherwise, we are storing a previously loaded copy. To do this,
// change the copy from copying the original value to just copying the
@@ -1803,7 +1803,7 @@
// Cannot determine.
if (!Cond || Cond->getType() != Type::Int1Ty)
return false;
- NewBB = BI->getSuccessor(!Cond->getBoolValue());
+ NewBB = BI->getSuccessor(!Cond->getZExtValue());
}
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(CurInst)) {
ConstantInt *Val =
diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp
index 5c0aa36..c0a7a05 100644
--- a/lib/Transforms/Instrumentation/RSProfiling.cpp
+++ b/lib/Transforms/Instrumentation/RSProfiling.cpp
@@ -460,7 +460,7 @@
//b:
new BranchInst(cast<BasicBlock>(Translate(dst)), bbC);
new BranchInst(dst, cast<BasicBlock>(Translate(dst)),
- ConstantInt::get(true), bbCp);
+ ConstantInt::get(Type::Int1Ty, true), bbCp);
//c:
{
TerminatorInst* iB = src->getTerminator();
@@ -516,7 +516,7 @@
TerminatorInst* T = F.getEntryBlock().getTerminator();
ReplaceInstWithInst(T, new BranchInst(T->getSuccessor(0),
cast<BasicBlock>(Translate(T->getSuccessor(0))),
- ConstantInt::get(true)));
+ ConstantInt::get(Type::Int1Ty, true)));
//do whatever is needed now that the function is duplicated
c->PrepFunction(&F);
diff --git a/lib/Transforms/Scalar/CondPropagate.cpp b/lib/Transforms/Scalar/CondPropagate.cpp
index 65e8c8d..253535e 100644
--- a/lib/Transforms/Scalar/CondPropagate.cpp
+++ b/lib/Transforms/Scalar/CondPropagate.cpp
@@ -139,7 +139,7 @@
// ultimate destination.
bool PHIGone = PN->getNumIncomingValues() == 2;
RevectorBlockTo(PN->getIncomingBlock(i-1),
- BI->getSuccessor(CB->getBoolValue() == 0));
+ BI->getSuccessor(CB->getZExtValue() == 0));
++NumBrThread;
// If there were two predecessors before this simplification, the PHI node
diff --git a/lib/Transforms/Scalar/CorrelatedExprs.cpp b/lib/Transforms/Scalar/CorrelatedExprs.cpp
index 09d5c07..00055b4 100644
--- a/lib/Transforms/Scalar/CorrelatedExprs.cpp
+++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp
@@ -472,7 +472,7 @@
} else if (CmpInst *CI = dyn_cast<CmpInst>(I)) {
Relation::KnownResult Res = getCmpResult(CI, NewRI);
if (Res == Relation::Unknown) return false;
- PropagateEquality(CI, ConstantInt::get(Res), NewRI);
+ PropagateEquality(CI, ConstantInt::get(Type::Int1Ty, Res), NewRI);
} else {
assert(isa<BranchInst>(*I) && "Unexpected instruction type!");
}
@@ -488,7 +488,7 @@
// Forward to the successor that corresponds to the branch we will take.
ForwardSuccessorTo(TI, SuccNo,
- BI->getSuccessor(!CB->getBoolValue()), NewRI);
+ BI->getSuccessor(!CB->getZExtValue()), NewRI);
return true;
}
@@ -841,7 +841,7 @@
// is true, this means that both operands to the OR are known to be true
// as well.
//
- if (CB->getBoolValue() && Inst->getOpcode() == Instruction::And) {
+ if (CB->getZExtValue() && Inst->getOpcode() == Instruction::And) {
PropagateEquality(Inst->getOperand(0), CB, RI);
PropagateEquality(Inst->getOperand(1), CB, RI);
}
@@ -850,24 +850,26 @@
// is false, this means that both operands to the OR are know to be false
// as well.
//
- if (!CB->getBoolValue() && Inst->getOpcode() == Instruction::Or) {
+ if (!CB->getZExtValue() && Inst->getOpcode() == Instruction::Or) {
PropagateEquality(Inst->getOperand(0), CB, RI);
PropagateEquality(Inst->getOperand(1), CB, RI);
}
- // If we know that this instruction is a NOT instruction, we know that the
- // operand is known to be the inverse of whatever the current value is.
+ // If we know that this instruction is a NOT instruction, we know that
+ // the operand is known to be the inverse of whatever the current
+ // value is.
//
if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(Inst))
if (BinaryOperator::isNot(BOp))
PropagateEquality(BinaryOperator::getNotArgument(BOp),
- ConstantInt::get(!CB->getBoolValue()), RI);
+ ConstantInt::get(Type::Int1Ty,
+ !CB->getZExtValue()), RI);
// If we know the value of a FCmp instruction, propagate the information
// about the relation into this region as well.
//
if (FCmpInst *FCI = dyn_cast<FCmpInst>(Inst)) {
- if (CB->getBoolValue()) { // If we know the condition is true...
+ if (CB->getZExtValue()) { // If we know the condition is true...
// Propagate info about the LHS to the RHS & RHS to LHS
PropagateRelation(FCI->getPredicate(), FCI->getOperand(0),
FCI->getOperand(1), RI);
@@ -888,7 +890,7 @@
// about the relation into this region as well.
//
if (ICmpInst *ICI = dyn_cast<ICmpInst>(Inst)) {
- if (CB->getBoolValue()) { // If we know the condition is true...
+ if (CB->getZExtValue()) { // If we know the condition is true...
// Propagate info about the LHS to the RHS & RHS to LHS
PropagateRelation(ICI->getPredicate(), ICI->getOperand(0),
ICI->getOperand(1), RI);
@@ -994,7 +996,7 @@
// See if we can figure out a result for this instruction...
Relation::KnownResult Result = getCmpResult(CI, RI);
if (Result != Relation::Unknown) {
- PropagateEquality(CI, ConstantInt::get(Result != 0), RI);
+ PropagateEquality(CI, ConstantInt::get(Type::Int1Ty, Result != 0), RI);
}
}
}
@@ -1068,7 +1070,7 @@
DEBUG(cerr << "Replacing icmp with " << Result
<< " constant: " << *CI);
- CI->replaceAllUsesWith(ConstantInt::get((bool)Result));
+ CI->replaceAllUsesWith(ConstantInt::get(Type::Int1Ty, (bool)Result));
// The instruction is now dead, remove it from the program.
CI->getParent()->getInstList().erase(CI);
++NumCmpRemoved;
@@ -1122,7 +1124,7 @@
if (Constant *Result = ConstantFoldInstruction(CI)) {
// Wow, this is easy, directly eliminate the ICmpInst.
DEBUG(cerr << "Replacing cmp with constant fold: " << *CI);
- return cast<ConstantInt>(Result)->getBoolValue()
+ return cast<ConstantInt>(Result)->getZExtValue()
? Relation::KnownTrue : Relation::KnownFalse;
}
} else {
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index bf4f5f3..c039b39 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -2965,7 +2965,7 @@
bool isSigned, bool Inside,
Instruction &IB) {
assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ?
- ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getBoolValue() &&
+ ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() &&
"Lo is not <= Hi in range emission code!");
if (Inside) {
@@ -3264,7 +3264,7 @@
ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
Constant *Cmp = ConstantExpr::getICmp(GT, LHSCst, RHSCst);
ICmpInst *LHS = cast<ICmpInst>(Op0);
- if (cast<ConstantInt>(Cmp)->getBoolValue()) {
+ if (cast<ConstantInt>(Cmp)->getZExtValue()) {
std::swap(LHS, RHS);
std::swap(LHSCst, RHSCst);
std::swap(LHSCC, RHSCC);
@@ -3723,7 +3723,7 @@
ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
Constant *Cmp = ConstantExpr::getICmp(GT, LHSCst, RHSCst);
ICmpInst *LHS = cast<ICmpInst>(Op0);
- if (cast<ConstantInt>(Cmp)->getBoolValue()) {
+ if (cast<ConstantInt>(Cmp)->getZExtValue()) {
std::swap(LHS, RHS);
std::swap(LHSCst, RHSCst);
std::swap(LHSCC, RHSCC);
@@ -4152,7 +4152,8 @@
EmitIt = false; // This is indexing into a zero sized array?
} else if (isa<ConstantInt>(C))
return ReplaceInstUsesWith(I, // No comparison is needed here.
- ConstantInt::get(Cond == ICmpInst::ICMP_NE));
+ ConstantInt::get(Type::Int1Ty,
+ Cond == ICmpInst::ICMP_NE));
}
if (EmitIt) {
@@ -4176,7 +4177,8 @@
return InVal;
else
// No comparison is needed here, all indexes = 0
- ReplaceInstUsesWith(I, ConstantInt::get(Cond == ICmpInst::ICMP_EQ));
+ ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ Cond == ICmpInst::ICMP_EQ));
}
// Only lower this if the icmp is the only user of the GEP or if we expect
@@ -4253,7 +4255,8 @@
if (NumDifferences == 0) // SAME GEP?
return ReplaceInstUsesWith(I, // No comparison is needed here.
- ConstantInt::get(Cond == ICmpInst::ICMP_EQ));
+ ConstantInt::get(Type::Int1Ty,
+ Cond == ICmpInst::ICMP_EQ));
else if (NumDifferences == 1) {
Value *LHSV = GEPLHS->getOperand(DiffOperand);
Value *RHSV = GEPRHS->getOperand(DiffOperand);
@@ -4281,7 +4284,8 @@
// fcmp pred X, X
if (Op0 == Op1)
- return ReplaceInstUsesWith(I, ConstantInt::get(isTrueWhenEqual(I)));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ isTrueWhenEqual(I)));
if (isa<UndefValue>(Op1)) // fcmp pred X, undef -> undef
return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty));
@@ -4333,7 +4337,8 @@
// icmp X, X
if (Op0 == Op1)
- return ReplaceInstUsesWith(I, ConstantInt::get(isTrueWhenEqual(I)));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ isTrueWhenEqual(I)));
if (isa<UndefValue>(Op1)) // X icmp undef -> undef
return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty));
@@ -4343,7 +4348,8 @@
if (GlobalValue *GV0 = dyn_cast<GlobalValue>(Op0))
if (GlobalValue *GV1 = dyn_cast<GlobalValue>(Op1))
if (!GV0->hasExternalWeakLinkage() || !GV1->hasExternalWeakLinkage())
- return ReplaceInstUsesWith(I, ConstantInt::get(!isTrueWhenEqual(I)));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ !isTrueWhenEqual(I)));
// icmp <global/alloca*/null>, <global/alloca*/null> - Global/Stack value
// addresses never equal each other! We already know that Op0 != Op1.
@@ -4351,7 +4357,8 @@
isa<ConstantPointerNull>(Op0)) &&
(isa<GlobalValue>(Op1) || isa<AllocaInst>(Op1) ||
isa<ConstantPointerNull>(Op1)))
- return ReplaceInstUsesWith(I, ConstantInt::get(!isTrueWhenEqual(I)));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ !isTrueWhenEqual(I)));
// icmp's with boolean values can always be turned into bitwise operations
if (Ty == Type::Int1Ty) {
@@ -4691,7 +4698,7 @@
ConstantExpr::getShl(ConstantExpr::getLShr(CI, ShAmt), ShAmt);
if (Comp != CI) {// Comparing against a bit that we know is zero.
bool IsICMP_NE = I.getPredicate() == ICmpInst::ICMP_NE;
- Constant *Cst = ConstantInt::get(IsICMP_NE);
+ Constant *Cst = ConstantInt::get(Type::Int1Ty, IsICMP_NE);
return ReplaceInstUsesWith(I, Cst);
}
@@ -4735,7 +4742,7 @@
if (Comp != CI) {// Comparing against a bit that we know is zero.
bool IsICMP_NE = I.getPredicate() == ICmpInst::ICMP_NE;
- Constant *Cst = ConstantInt::get(IsICMP_NE);
+ Constant *Cst = ConstantInt::get(Type::Int1Ty, IsICMP_NE);
return ReplaceInstUsesWith(I, Cst);
}
@@ -4957,7 +4964,8 @@
if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) {
Constant *NotCI = ConstantExpr::getNot(CI);
if (!ConstantExpr::getAnd(BOC, NotCI)->isNullValue())
- return ReplaceInstUsesWith(I, ConstantInt::get(isICMP_NE));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ isICMP_NE));
}
break;
@@ -4967,7 +4975,8 @@
// comparison can never succeed!
if (!ConstantExpr::getAnd(CI,
ConstantExpr::getNot(BOC))->isNullValue())
- return ReplaceInstUsesWith(I, ConstantInt::get(isICMP_NE));
+ return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty,
+ isICMP_NE));
// If we have ((X & C) == C), turn it into ((X & C) != 0).
if (CI == BOC && isOneBitSet(CI))
@@ -6182,7 +6191,7 @@
if (Op1CV && (Op1CV != (KnownZero^TypeMask))) {
// (X&4) == 2 --> false
// (X&4) != 2 --> true
- Constant *Res = ConstantInt::get(isNE);
+ Constant *Res = ConstantInt::get(Type::Int1Ty, isNE);
Res = ConstantExpr::getZExt(Res, CI.getType());
return ReplaceInstUsesWith(CI, Res);
}
@@ -6553,7 +6562,7 @@
// select true, X, Y -> X
// select false, X, Y -> Y
if (ConstantInt *C = dyn_cast<ConstantInt>(CondVal))
- return ReplaceInstUsesWith(SI, C->getBoolValue() ? TrueVal : FalseVal);
+ return ReplaceInstUsesWith(SI, C->getZExtValue() ? TrueVal : FalseVal);
// select C, X, X -> X
if (TrueVal == FalseVal)
@@ -6574,7 +6583,7 @@
ConstantInt *C;
if ((C = dyn_cast<ConstantInt>(TrueVal)) &&
C->getType() == Type::Int1Ty) {
- if (C->getBoolValue()) {
+ if (C->getZExtValue()) {
// Change: A = select B, true, C --> A = or B, C
return BinaryOperator::createOr(CondVal, FalseVal);
} else {
@@ -6586,7 +6595,7 @@
}
} else if ((C = dyn_cast<ConstantInt>(FalseVal)) &&
C->getType() == Type::Int1Ty) {
- if (C->getBoolValue() == false) {
+ if (C->getZExtValue() == false) {
// Change: A = select B, C, false --> A = and B, C
return BinaryOperator::createAnd(CondVal, TrueVal);
} else {
@@ -9049,7 +9058,7 @@
if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
if (BI->isConditional() && isa<ConstantInt>(BI->getCondition()) &&
BI->getCondition()->getType() == Type::Int1Ty) {
- bool CondVal = cast<ConstantInt>(BI->getCondition())->getBoolValue();
+ bool CondVal = cast<ConstantInt>(BI->getCondition())->getZExtValue();
AddReachableCodeToWorklist(BI->getSuccessor(!CondVal), Visited, WorkList,
TD);
return;
diff --git a/lib/Transforms/Scalar/LoopUnswitch.cpp b/lib/Transforms/Scalar/LoopUnswitch.cpp
index c97c9b5..80d4311 100644
--- a/lib/Transforms/Scalar/LoopUnswitch.cpp
+++ b/lib/Transforms/Scalar/LoopUnswitch.cpp
@@ -924,7 +924,8 @@
if (IsEqual)
Replacement = Val;
else
- Replacement = ConstantInt::get(!cast<ConstantInt>(Val)->getBoolValue());
+ Replacement = ConstantInt::get(Type::Int1Ty,
+ !cast<ConstantInt>(Val)->getZExtValue());
for (unsigned i = 0, e = Users.size(); i != e; ++i)
if (Instruction *U = cast<Instruction>(Users[i])) {
@@ -1026,7 +1027,7 @@
switch (I->getOpcode()) {
case Instruction::Select:
if (ConstantInt *CB = dyn_cast<ConstantInt>(I->getOperand(0))) {
- ReplaceUsesOfWith(I, I->getOperand(!CB->getBoolValue()+1), Worklist);
+ ReplaceUsesOfWith(I, I->getOperand(!CB->getZExtValue()+1), Worklist);
continue;
}
break;
@@ -1036,7 +1037,7 @@
cast<BinaryOperator>(I)->swapOperands();
if (ConstantInt *CB = dyn_cast<ConstantInt>(I->getOperand(1)))
if (CB->getType() == Type::Int1Ty) {
- if (CB->getBoolValue()) // X & 1 -> X
+ if (CB->getZExtValue()) // X & 1 -> X
ReplaceUsesOfWith(I, I->getOperand(0), Worklist);
else // X & 0 -> 0
ReplaceUsesOfWith(I, I->getOperand(1), Worklist);
@@ -1049,7 +1050,7 @@
cast<BinaryOperator>(I)->swapOperands();
if (ConstantInt *CB = dyn_cast<ConstantInt>(I->getOperand(1)))
if (CB->getType() == Type::Int1Ty) {
- if (CB->getBoolValue()) // X | 1 -> 1
+ if (CB->getZExtValue()) // X | 1 -> 1
ReplaceUsesOfWith(I, I->getOperand(1), Worklist);
else // X | 0 -> X
ReplaceUsesOfWith(I, I->getOperand(0), Worklist);
@@ -1094,8 +1095,8 @@
break; // FIXME: Enable.
DOUT << "Folded branch: " << *BI;
- BasicBlock *DeadSucc = BI->getSuccessor(CB->getBoolValue());
- BasicBlock *LiveSucc = BI->getSuccessor(!CB->getBoolValue());
+ BasicBlock *DeadSucc = BI->getSuccessor(CB->getZExtValue());
+ BasicBlock *LiveSucc = BI->getSuccessor(!CB->getZExtValue());
DeadSucc->removePredecessor(BI->getParent(), true);
Worklist.push_back(new BranchInst(LiveSucc, BI));
BI->eraseFromParent();
diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index daf21d4..2bc0004 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -416,8 +416,7 @@
} else {
LatticeVal &BCValue = getValueState(BI->getCondition());
if (BCValue.isOverdefined() ||
- (BCValue.isConstant() &&
- BCValue.getConstant()->getType() != Type::Int1Ty)) {
+ (BCValue.isConstant() && !isa<ConstantInt>(BCValue.getConstant()))) {
// Overdefined condition variables, and branches on unfoldable constant
// conditions, mean the branch could go either way.
Succs[0] = Succs[1] = true;
@@ -647,10 +646,9 @@
LatticeVal &CondValue = getValueState(I.getCondition());
if (CondValue.isUndefined())
return;
- if (CondValue.isConstant() &&
- CondValue.getConstant()->getType() == Type::Int1Ty) {
+ if (CondValue.isConstant()) {
if (ConstantInt *CondCB = dyn_cast<ConstantInt>(CondValue.getConstant())){
- mergeInValue(&I, getValueState(CondCB->getBoolValue() ? I.getTrueValue()
+ mergeInValue(&I, getValueState(CondCB->getZExtValue() ? I.getTrueValue()
: I.getFalseValue()));
return;
}
diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp
index cb98dc5..753d657 100644
--- a/lib/Transforms/Utils/CloneFunction.cpp
+++ b/lib/Transforms/Utils/CloneFunction.cpp
@@ -233,7 +233,7 @@
// Constant fold to uncond branch!
if (Cond) {
- BasicBlock *Dest = BI->getSuccessor(!Cond->getBoolValue());
+ BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue());
ValueMap[OldTI] = new BranchInst(Dest, NewBB);
CloneBlock(Dest);
TerminatorDone = true;
diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index 4e8f3c0..e83f1b0 100644
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -470,7 +470,7 @@
case 0:
case 1: break; // No value needed.
case 2: // Conditional branch, return a bool
- brVal = ConstantInt::get(!SuccNum);
+ brVal = ConstantInt::get(Type::Int1Ty, !SuccNum);
break;
default:
brVal = ConstantInt::get(Type::Int16Ty, SuccNum);
diff --git a/lib/Transforms/Utils/Local.cpp b/lib/Transforms/Utils/Local.cpp
index f3d6ca8..fd24f10 100644
--- a/lib/Transforms/Utils/Local.cpp
+++ b/lib/Transforms/Utils/Local.cpp
@@ -176,8 +176,8 @@
if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
// Are we branching on constant?
// YES. Change to unconditional branch...
- BasicBlock *Destination = Cond->getBoolValue() ? Dest1 : Dest2;
- BasicBlock *OldDest = Cond->getBoolValue() ? Dest2 : Dest1;
+ BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
+ BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1;
//cerr << "Function: " << T->getParent()->getParent()
// << "\nRemoving branch from " << T->getParent()
diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index 964b47c..25bc168 100644
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -975,7 +975,7 @@
// Okay, we now know that all edges from PredBB should be revectored to
// branch to RealDest.
BasicBlock *PredBB = PN->getIncomingBlock(i);
- BasicBlock *RealDest = BI->getSuccessor(!CB->getBoolValue());
+ BasicBlock *RealDest = BI->getSuccessor(!CB->getZExtValue());
if (RealDest == BB) continue; // Skip self loops.
@@ -1500,8 +1500,8 @@
if (PBI != BI && PBI->isConditional()) {
// If this block ends with a branch instruction, and if there is a
- // predecessor that ends on a branch of the same condition, make this
- // conditional branch redundant.
+ // predecessor that ends on a branch of the same condition, make
+ // this conditional branch redundant.
if (PBI->getCondition() == BI->getCondition() &&
PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
// Okay, the outcome of this conditional branch is statically
@@ -1509,23 +1509,24 @@
if (BB->getSinglePredecessor()) {
// Turn this into a branch on constant.
bool CondIsTrue = PBI->getSuccessor(0) == BB;
- BI->setCondition(ConstantInt::get(CondIsTrue));
+ BI->setCondition(ConstantInt::get(Type::Int1Ty, CondIsTrue));
return SimplifyCFG(BB); // Nuke the branch on constant.
}
- // Otherwise, if there are multiple predecessors, insert a PHI that
- // merges in the constant and simplify the block result.
+ // Otherwise, if there are multiple predecessors, insert a PHI
+ // that merges in the constant and simplify the block result.
if (BlockIsSimpleEnoughToThreadThrough(BB)) {
PHINode *NewPN = new PHINode(Type::Int1Ty,
- BI->getCondition()->getName()+".pr",
- BB->begin());
+ BI->getCondition()->getName()+".pr",
+ BB->begin());
for (PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
if ((PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) &&
PBI != BI && PBI->isConditional() &&
PBI->getCondition() == BI->getCondition() &&
PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
bool CondIsTrue = PBI->getSuccessor(0) == BB;
- NewPN->addIncoming(ConstantInt::get(CondIsTrue), *PI);
+ NewPN->addIncoming(ConstantInt::get(Type::Int1Ty,
+ CondIsTrue), *PI);
} else {
NewPN->addIncoming(BI->getCondition(), *PI);
}
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 09f6fee..138ab35 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -440,8 +440,9 @@
static std::string Indent = "\n";
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
if (CI->getType() == Type::Int1Ty)
- Out << (CI->getBoolValue() ? "true" : "false");
- else Out << CI->getSExtValue();
+ Out << (CI->getZExtValue() ? "true" : "false");
+ else
+ Out << CI->getSExtValue();
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
// We would like to output the FP constant value in exponential notation,
// but we cannot do this if doing so will lose precision. Check here to
diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index 85e5992..1f5aeb3 100644
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -317,8 +317,7 @@
const Constant *V1,
const Constant *V2) {
if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
- if (CB->getType() == Type::Int1Ty)
- return const_cast<Constant*>(CB->getBoolValue() ? V1 : V2);
+ return const_cast<Constant*>(CB->getZExtValue() ? V1 : V2);
if (isa<UndefValue>(V1)) return const_cast<Constant*>(V2);
if (isa<UndefValue>(V2)) return const_cast<Constant*>(V1);
@@ -560,11 +559,14 @@
default:
break;
case Instruction::And:
- return ConstantInt::get(CI1->getBoolValue() & CI2->getBoolValue());
+ return ConstantInt::get(Type::Int1Ty,
+ CI1->getZExtValue() & CI2->getZExtValue());
case Instruction::Or:
- return ConstantInt::get(CI1->getBoolValue() | CI2->getBoolValue());
+ return ConstantInt::get(Type::Int1Ty,
+ CI1->getZExtValue() | CI2->getZExtValue());
case Instruction::Xor:
- return ConstantInt::get(CI1->getBoolValue() ^ CI2->getBoolValue());
+ return ConstantInt::get(Type::Int1Ty,
+ CI1->getZExtValue() ^ CI2->getZExtValue());
}
} else {
uint64_t C1Val = CI1->getZExtValue();
@@ -765,15 +767,15 @@
Constant *C2 = const_cast<Constant*>(V2);
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return FCmpInst::FCMP_OEQ;
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return FCmpInst::FCMP_OLT;
R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return FCmpInst::FCMP_OGT;
// Nothing more we can do
@@ -832,15 +834,15 @@
Constant *C2 = const_cast<Constant*>(V2);
ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return pred;
pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return pred;
pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getBoolValue())
+ if (R && R->getZExtValue())
return pred;
// If we couldn't figure it out, bail.
@@ -1059,20 +1061,30 @@
if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2) &&
C1->getType() == Type::Int1Ty && C2->getType() == Type::Int1Ty) {
- bool C1Val = cast<ConstantInt>(C1)->getBoolValue();
- bool C2Val = cast<ConstantInt>(C2)->getBoolValue();
+ bool C1Val = cast<ConstantInt>(C1)->getZExtValue();
+ bool C2Val = cast<ConstantInt>(C2)->getZExtValue();
switch (pred) {
default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_EQ: return ConstantInt::get(C1Val == C2Val);
- case ICmpInst::ICMP_NE: return ConstantInt::get(C1Val != C2Val);
- case ICmpInst::ICMP_ULT:return ConstantInt::get(C1Val < C2Val);
- case ICmpInst::ICMP_UGT:return ConstantInt::get(C1Val > C2Val);
- case ICmpInst::ICMP_ULE:return ConstantInt::get(C1Val <= C2Val);
- case ICmpInst::ICMP_UGE:return ConstantInt::get(C1Val >= C2Val);
- case ICmpInst::ICMP_SLT:return ConstantInt::get(C1Val < C2Val);
- case ICmpInst::ICMP_SGT:return ConstantInt::get(C1Val > C2Val);
- case ICmpInst::ICMP_SLE:return ConstantInt::get(C1Val <= C2Val);
- case ICmpInst::ICMP_SGE:return ConstantInt::get(C1Val >= C2Val);
+ case ICmpInst::ICMP_EQ:
+ return ConstantInt::get(Type::Int1Ty, C1Val == C2Val);
+ case ICmpInst::ICMP_NE:
+ return ConstantInt::get(Type::Int1Ty, C1Val != C2Val);
+ case ICmpInst::ICMP_ULT:
+ return ConstantInt::get(Type::Int1Ty, C1Val < C2Val);
+ case ICmpInst::ICMP_UGT:
+ return ConstantInt::get(Type::Int1Ty, C1Val > C2Val);
+ case ICmpInst::ICMP_ULE:
+ return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val);
+ case ICmpInst::ICMP_UGE:
+ return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
+ case ICmpInst::ICMP_SLT:
+ return ConstantInt::get(Type::Int1Ty, C1Val < C2Val);
+ case ICmpInst::ICMP_SGT:
+ return ConstantInt::get(Type::Int1Ty, C1Val > C2Val);
+ case ICmpInst::ICMP_SLE:
+ return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val);
+ case ICmpInst::ICMP_SGE:
+ return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
}
} else if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
if (ICmpInst::isSignedPredicate(ICmpInst::Predicate(pred))) {
@@ -1080,22 +1092,22 @@
int64_t V2 = cast<ConstantInt>(C2)->getSExtValue();
switch (pred) {
default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_SLT:return ConstantInt::get(V1 < V2);
- case ICmpInst::ICMP_SGT:return ConstantInt::get(V1 > V2);
- case ICmpInst::ICMP_SLE:return ConstantInt::get(V1 <= V2);
- case ICmpInst::ICMP_SGE:return ConstantInt::get(V1 >= V2);
+ case ICmpInst::ICMP_SLT:return ConstantInt::get(Type::Int1Ty, V1 < V2);
+ case ICmpInst::ICMP_SGT:return ConstantInt::get(Type::Int1Ty, V1 > V2);
+ case ICmpInst::ICMP_SLE:return ConstantInt::get(Type::Int1Ty, V1 <= V2);
+ case ICmpInst::ICMP_SGE:return ConstantInt::get(Type::Int1Ty, V1 >= V2);
}
} else {
uint64_t V1 = cast<ConstantInt>(C1)->getZExtValue();
uint64_t V2 = cast<ConstantInt>(C2)->getZExtValue();
switch (pred) {
default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_EQ: return ConstantInt::get(V1 == V2);
- case ICmpInst::ICMP_NE: return ConstantInt::get(V1 != V2);
- case ICmpInst::ICMP_ULT:return ConstantInt::get(V1 < V2);
- case ICmpInst::ICMP_UGT:return ConstantInt::get(V1 > V2);
- case ICmpInst::ICMP_ULE:return ConstantInt::get(V1 <= V2);
- case ICmpInst::ICMP_UGE:return ConstantInt::get(V1 >= V2);
+ case ICmpInst::ICMP_EQ: return ConstantInt::get(Type::Int1Ty, V1 == V2);
+ case ICmpInst::ICMP_NE: return ConstantInt::get(Type::Int1Ty, V1 != V2);
+ case ICmpInst::ICMP_ULT:return ConstantInt::get(Type::Int1Ty, V1 < V2);
+ case ICmpInst::ICMP_UGT:return ConstantInt::get(Type::Int1Ty, V1 > V2);
+ case ICmpInst::ICMP_ULE:return ConstantInt::get(Type::Int1Ty, V1 <= V2);
+ case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1 >= V2);
}
}
} else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
@@ -1106,39 +1118,45 @@
case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse();
case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue();
case FCmpInst::FCMP_UNO:
- return ConstantInt::get(C1Val != C1Val || C2Val != C2Val);
+ return ConstantInt::get(Type::Int1Ty, C1Val != C1Val || C2Val != C2Val);
case FCmpInst::FCMP_ORD:
- return ConstantInt::get(C1Val == C1Val && C2Val == C2Val);
+ return ConstantInt::get(Type::Int1Ty, C1Val == C1Val && C2Val == C2Val);
case FCmpInst::FCMP_UEQ:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OEQ: return ConstantInt::get(C1Val == C2Val);
+ case FCmpInst::FCMP_OEQ:
+ return ConstantInt::get(Type::Int1Ty, C1Val == C2Val);
case FCmpInst::FCMP_UNE:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_ONE: return ConstantInt::get(C1Val != C2Val);
+ case FCmpInst::FCMP_ONE:
+ return ConstantInt::get(Type::Int1Ty, C1Val != C2Val);
case FCmpInst::FCMP_ULT:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OLT: return ConstantInt::get(C1Val < C2Val);
+ case FCmpInst::FCMP_OLT:
+ return ConstantInt::get(Type::Int1Ty, C1Val < C2Val);
case FCmpInst::FCMP_UGT:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OGT: return ConstantInt::get(C1Val > C2Val);
+ case FCmpInst::FCMP_OGT:
+ return ConstantInt::get(Type::Int1Ty, C1Val > C2Val);
case FCmpInst::FCMP_ULE:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OLE: return ConstantInt::get(C1Val <= C2Val);
+ case FCmpInst::FCMP_OLE:
+ return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val);
case FCmpInst::FCMP_UGE:
if (C1Val != C1Val || C2Val != C2Val)
return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OGE: return ConstantInt::get(C1Val >= C2Val);
+ case FCmpInst::FCMP_OGE:
+ return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val);
}
} else if (const ConstantPacked *CP1 = dyn_cast<ConstantPacked>(C1)) {
if (const ConstantPacked *CP2 = dyn_cast<ConstantPacked>(C2)) {
@@ -1182,17 +1200,17 @@
case FCmpInst::BAD_FCMP_PREDICATE:
break; // Couldn't determine anything about these constants.
case FCmpInst::FCMP_OEQ: // We know that C1 == C2
- return ConstantInt::get(
+ return ConstantInt::get(Type::Int1Ty,
pred == FCmpInst::FCMP_UEQ || pred == FCmpInst::FCMP_OEQ ||
pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE ||
pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
case FCmpInst::FCMP_OLT: // We know that C1 < C2
- return ConstantInt::get(
+ return ConstantInt::get(Type::Int1Ty,
pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT ||
pred == FCmpInst::FCMP_ULE || pred == FCmpInst::FCMP_OLE);
case FCmpInst::FCMP_OGT: // We know that C1 > C2
- return ConstantInt::get(
+ return ConstantInt::get(Type::Int1Ty,
pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
@@ -1227,7 +1245,8 @@
case ICmpInst::ICMP_EQ: // We know the constants are equal!
// If we know the constants are equal, we can decide the result of this
// computation precisely.
- return ConstantInt::get(pred == ICmpInst::ICMP_EQ ||
+ return ConstantInt::get(Type::Int1Ty,
+ pred == ICmpInst::ICMP_EQ ||
pred == ICmpInst::ICMP_ULE ||
pred == ICmpInst::ICMP_SLE ||
pred == ICmpInst::ICMP_UGE ||
@@ -1235,25 +1254,29 @@
case ICmpInst::ICMP_ULT:
// If we know that C1 < C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(pred == ICmpInst::ICMP_ULT ||
+ return ConstantInt::get(Type::Int1Ty,
+ pred == ICmpInst::ICMP_ULT ||
pred == ICmpInst::ICMP_NE ||
pred == ICmpInst::ICMP_ULE);
case ICmpInst::ICMP_SLT:
// If we know that C1 < C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(pred == ICmpInst::ICMP_SLT ||
+ return ConstantInt::get(Type::Int1Ty,
+ pred == ICmpInst::ICMP_SLT ||
pred == ICmpInst::ICMP_NE ||
pred == ICmpInst::ICMP_SLE);
case ICmpInst::ICMP_UGT:
// If we know that C1 > C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(pred == ICmpInst::ICMP_UGT ||
+ return ConstantInt::get(Type::Int1Ty,
+ pred == ICmpInst::ICMP_UGT ||
pred == ICmpInst::ICMP_NE ||
pred == ICmpInst::ICMP_UGE);
case ICmpInst::ICMP_SGT:
// If we know that C1 > C2, we can decide the result of this computation
// precisely.
- return ConstantInt::get(pred == ICmpInst::ICMP_SGT ||
+ return ConstantInt::get(Type::Int1Ty,
+ pred == ICmpInst::ICMP_SGT ||
pred == ICmpInst::ICMP_NE ||
pred == ICmpInst::ICMP_SGE);
case ICmpInst::ICMP_ULE:
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 4850290..7349091 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -93,7 +93,7 @@
Constant *Constant::getNullValue(const Type *Ty) {
switch (Ty->getTypeID()) {
case Type::Int1TyID: {
- static Constant *NullBool = ConstantInt::get(false);
+ static Constant *NullBool = ConstantInt::get(Type::Int1Ty, false);
return NullBool;
}
case Type::Int8TyID: {
@@ -838,7 +838,11 @@
// just return the stored value while getSExtValue has to convert back to sign
// extended. getZExtValue is more common in LLVM than getSExtValue().
ConstantInt *ConstantInt::get(const Type *Ty, int64_t V) {
- if (Ty == Type::Int1Ty) return ConstantInt::get(V&1);
+ if (Ty == Type::Int1Ty)
+ if (V & 1)
+ return getTrue();
+ else
+ return getFalse();
return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
}
diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 4e6fe6b..1f6cbaf 100644
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -671,7 +671,7 @@
if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
if (CI->getType() == Type::Int1Ty)
Out << "ConstantInt* " << constName << " = ConstantInt::get("
- << (CI->getBoolValue() ? "true" : "false") << ");";
+ << (CI->getZExtValue() ? "true" : "false") << ");";
else
Out << "ConstantInt* " << constName << " = ConstantInt::get("
<< typeName << ", " << CI->getZExtValue() << ");";