[llvm-commits] CVS: llvm/lib/VMCore/AsmWriter.cpp ConstantFolding.cpp Constants.cpp Instructions.cpp
Zhou Sheng
zhousheng00 at gmail.com
Thu Jan 11 04:25:08 PST 2007
Changes in directory llvm/lib/VMCore:
AsmWriter.cpp updated: 1.246 -> 1.247
ConstantFolding.cpp updated: 1.126 -> 1.127
Constants.cpp updated: 1.194 -> 1.195
Instructions.cpp updated: 1.58 -> 1.59
---
Log message:
For PR1043: http://llvm.org/PR1043 :
Merge ConstantIntegral and ConstantBool into ConstantInt.
Remove ConstantIntegral and ConstantBool from LLVM.
---
Diffs of the changes: (+189 -212)
AsmWriter.cpp | 8 -
ConstantFolding.cpp | 340 +++++++++++++++++++++++++---------------------------
Constants.cpp | 43 +-----
Instructions.cpp | 10 -
4 files changed, 189 insertions(+), 212 deletions(-)
Index: llvm/lib/VMCore/AsmWriter.cpp
diff -u llvm/lib/VMCore/AsmWriter.cpp:1.246 llvm/lib/VMCore/AsmWriter.cpp:1.247
--- llvm/lib/VMCore/AsmWriter.cpp:1.246 Thu Jan 11 01:58:19 2007
+++ llvm/lib/VMCore/AsmWriter.cpp Thu Jan 11 06:24:14 2007
@@ -438,10 +438,10 @@
SlotMachine *Machine) {
const int IndentSize = 4;
static std::string Indent = "\n";
- if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
- Out << (CB->getValue() ? "true" : "false");
- } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
- Out << CI->getSExtValue();
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
+ if (CI->getType() == Type::BoolTy)
+ Out << (CI->getBoolValue() ? "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
Index: llvm/lib/VMCore/ConstantFolding.cpp
diff -u llvm/lib/VMCore/ConstantFolding.cpp:1.126 llvm/lib/VMCore/ConstantFolding.cpp:1.127
--- llvm/lib/VMCore/ConstantFolding.cpp:1.126 Wed Jan 10 18:25:45 2007
+++ llvm/lib/VMCore/ConstantFolding.cpp Thu Jan 11 06:24:14 2007
@@ -174,11 +174,11 @@
return 0; // Can't fold.
case Instruction::FPToUI:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
- return ConstantIntegral::get(DestTy,(uint64_t) FPC->getValue());
+ return ConstantInt::get(DestTy,(uint64_t) FPC->getValue());
return 0; // Can't fold.
case Instruction::FPToSI:
if (const ConstantFP *FPC = dyn_cast<ConstantFP>(V))
- return ConstantIntegral::get(DestTy,(int64_t) FPC->getValue());
+ return ConstantInt::get(DestTy,(int64_t) FPC->getValue());
return 0; // Can't fold.
case Instruction::IntToPtr: //always treated as unsigned
if (V->isNullValue()) // Is it an integral null value?
@@ -186,27 +186,27 @@
return 0; // Other pointer types cannot be casted
case Instruction::PtrToInt: // always treated as unsigned
if (V->isNullValue()) // is it a null pointer value?
- return ConstantIntegral::get(DestTy, 0);
+ return ConstantInt::get(DestTy, 0);
return 0; // Other pointer types cannot be casted
case Instruction::UIToFP:
- if (const ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V))
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
return ConstantFP::get(DestTy, double(CI->getZExtValue()));
return 0;
case Instruction::SIToFP:
- if (const ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V))
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
return ConstantFP::get(DestTy, double(CI->getSExtValue()));
return 0;
case Instruction::ZExt:
- if (const ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V))
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
return ConstantInt::get(DestTy, CI->getZExtValue());
return 0;
case Instruction::SExt:
- if (const ConstantIntegral *CI = dyn_cast<ConstantIntegral>(V))
+ if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
return ConstantInt::get(DestTy, CI->getSExtValue());
return 0;
case Instruction::Trunc:
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) // Can't trunc a bool
- return ConstantIntegral::get(DestTy, CI->getZExtValue());
+ return ConstantInt::get(DestTy, CI->getZExtValue());
return 0;
case Instruction::BitCast:
if (SrcTy == DestTy)
@@ -316,8 +316,9 @@
Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond,
const Constant *V1,
const Constant *V2) {
- if (const ConstantBool *CB = dyn_cast<ConstantBool>(Cond))
- return const_cast<Constant*>(CB->getValue() ? V1 : V2);
+ if (const ConstantInt *CB = dyn_cast<ConstantInt>(Cond))
+ if (CB->getType() == Type::BoolTy)
+ return const_cast<Constant*>(CB->getBoolValue() ? V1 : V2);
if (isa<UndefValue>(V1)) return const_cast<Constant*>(V2);
if (isa<UndefValue>(V2)) return const_cast<Constant*>(V1);
@@ -552,76 +553,70 @@
// At this point we know neither constant is an UndefValue nor a ConstantExpr
// so look at directly computing the value.
- if (const ConstantBool *CB1 = dyn_cast<ConstantBool>(C1)) {
- if (const ConstantBool *CB2 = dyn_cast<ConstantBool>(C2)) {
- switch (Opcode) {
+ if (const ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
+ if (const ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
+ if (CI1->getType() == Type::BoolTy && CI2->getType() == Type::BoolTy) {
+ switch (Opcode) {
+ default:
+ break;
+ case Instruction::And:
+ return ConstantInt::get(CI1->getBoolValue() & CI2->getBoolValue());
+ case Instruction::Or:
+ return ConstantInt::get(CI1->getBoolValue() | CI2->getBoolValue());
+ case Instruction::Xor:
+ return ConstantInt::get(CI1->getBoolValue() ^ CI2->getBoolValue());
+ }
+ } else {
+ uint64_t C1Val = CI1->getZExtValue();
+ uint64_t C2Val = CI2->getZExtValue();
+ switch (Opcode) {
default:
break;
+ case Instruction::Add:
+ return ConstantInt::get(C1->getType(), C1Val + C2Val);
+ case Instruction::Sub:
+ return ConstantInt::get(C1->getType(), C1Val - C2Val);
+ case Instruction::Mul:
+ return ConstantInt::get(C1->getType(), C1Val * C2Val);
+ case Instruction::UDiv:
+ if (CI2->isNullValue()) // X / 0 -> can't fold
+ return 0;
+ return ConstantInt::get(C1->getType(), C1Val / C2Val);
+ case Instruction::SDiv:
+ if (CI2->isNullValue()) return 0; // X / 0 -> can't fold
+ if (CI2->isAllOnesValue() &&
+ (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
+ (CI1->getSExtValue() == INT64_MIN)) ||
+ (CI1->getSExtValue() == -CI1->getSExtValue())))
+ return 0; // MIN_INT / -1 -> overflow
+ return ConstantInt::get(C1->getType(),
+ CI1->getSExtValue() / CI2->getSExtValue());
+ case Instruction::URem:
+ if (C2->isNullValue()) return 0; // X / 0 -> can't fold
+ return ConstantInt::get(C1->getType(), C1Val % C2Val);
+ case Instruction::SRem:
+ if (CI2->isNullValue()) return 0; // X % 0 -> can't fold
+ if (CI2->isAllOnesValue() &&
+ (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
+ (CI1->getSExtValue() == INT64_MIN)) ||
+ (CI1->getSExtValue() == -CI1->getSExtValue())))
+ return 0; // MIN_INT % -1 -> overflow
+ return ConstantInt::get(C1->getType(),
+ CI1->getSExtValue() % CI2->getSExtValue());
case Instruction::And:
- return ConstantBool::get(CB1->getValue() & CB2->getValue());
+ return ConstantInt::get(C1->getType(), C1Val & C2Val);
case Instruction::Or:
- return ConstantBool::get(CB1->getValue() | CB2->getValue());
+ return ConstantInt::get(C1->getType(), C1Val | C2Val);
case Instruction::Xor:
- return ConstantBool::get(CB1->getValue() ^ CB2->getValue());
- }
- }
- } else if (const ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
- if (const ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
- uint64_t C1Val = CI1->getZExtValue();
- uint64_t C2Val = CI2->getZExtValue();
- switch (Opcode) {
- default:
- break;
- case Instruction::Add:
- return ConstantInt::get(C1->getType(), C1Val + C2Val);
- case Instruction::Sub:
- return ConstantInt::get(C1->getType(), C1Val - C2Val);
- case Instruction::Mul:
- return ConstantInt::get(C1->getType(), C1Val * C2Val);
- case Instruction::UDiv:
- if (CI2->isNullValue()) // X / 0 -> can't fold
- return 0;
- return ConstantInt::get(C1->getType(), C1Val / C2Val);
- case Instruction::SDiv:
- if (CI2->isNullValue()) return 0; // X / 0 -> can't fold
- if (CI2->isAllOnesValue() &&
- (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
- (CI1->getSExtValue() == INT64_MIN)) ||
- (CI1->getSExtValue() == -CI1->getSExtValue())))
- return 0; // MIN_INT / -1 -> overflow
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() / CI2->getSExtValue());
- case Instruction::URem:
- if (C2->isNullValue()) return 0; // X / 0 -> can't fold
- return ConstantInt::get(C1->getType(), C1Val % C2Val);
- case Instruction::SRem:
- if (CI2->isNullValue()) return 0; // X % 0 -> can't fold
- if (CI2->isAllOnesValue() &&
- (((CI1->getType()->getPrimitiveSizeInBits() == 64) &&
- (CI1->getSExtValue() == INT64_MIN)) ||
- (CI1->getSExtValue() == -CI1->getSExtValue())))
- return 0; // MIN_INT % -1 -> overflow
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() % CI2->getSExtValue());
- case Instruction::And:
- return ConstantInt::get(C1->getType(), C1Val & C2Val);
- case Instruction::Or:
- return ConstantInt::get(C1->getType(), C1Val | C2Val);
- case Instruction::Xor:
- return ConstantInt::get(C1->getType(), C1Val ^ C2Val);
- case Instruction::Shl:
- if (C2Val >= CI1->getType()->getPrimitiveSizeInBits())
- C2Val = CI1->getType()->getPrimitiveSizeInBits() - 1;
- return ConstantInt::get(C1->getType(), C1Val << C2Val);
- case Instruction::LShr:
- if (C2Val >= CI1->getType()->getPrimitiveSizeInBits())
- C2Val = CI1->getType()->getPrimitiveSizeInBits() - 1;
- return ConstantInt::get(C1->getType(), C1Val >> C2Val);
- case Instruction::AShr:
- if (C2Val >= CI1->getType()->getPrimitiveSizeInBits())
- C2Val = CI1->getType()->getPrimitiveSizeInBits() - 1;
- return ConstantInt::get(C1->getType(),
- CI1->getSExtValue() >> C2Val);
+ return ConstantInt::get(C1->getType(), C1Val ^ C2Val);
+ case Instruction::Shl:
+ return ConstantInt::get(C1->getType(), C1Val << C2Val);
+ case Instruction::LShr:
+ return ConstantInt::get(C1->getType(), C1Val >> C2Val);
+ case Instruction::AShr:
+ return ConstantInt::get(C1->getType(),
+ CI1->getSExtValue() >> C2Val);
+ }
}
}
} else if (const ConstantFP *CFP1 = dyn_cast<ConstantFP>(C1)) {
@@ -765,20 +760,20 @@
if (!isa<ConstantExpr>(V1)) {
if (!isa<ConstantExpr>(V2)) {
// We distilled thisUse the standard constant folder for a few cases
- ConstantBool *R = 0;
+ ConstantInt *R = 0;
Constant *C1 = const_cast<Constant*>(V1);
Constant *C2 = const_cast<Constant*>(V2);
- R = dyn_cast<ConstantBool>(
+ R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2));
- if (R && R->getValue())
+ if (R && R->getBoolValue())
return FCmpInst::FCMP_OEQ;
- R = dyn_cast<ConstantBool>(
+ R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2));
- if (R && R->getValue())
+ if (R && R->getBoolValue())
return FCmpInst::FCMP_OLT;
- R = dyn_cast<ConstantBool>(
+ R = dyn_cast<ConstantInt>(
ConstantExpr::getFCmp(FCmpInst::FCMP_OGT, C1, C2));
- if (R && R->getValue())
+ if (R && R->getBoolValue())
return FCmpInst::FCMP_OGT;
// Nothing more we can do
@@ -832,20 +827,20 @@
if (!isa<GlobalValue>(V2) && !isa<ConstantExpr>(V2)) {
// We distilled this down to a simple case, use the standard constant
// folder.
- ConstantBool *R = 0;
+ ConstantInt *R = 0;
Constant *C1 = const_cast<Constant*>(V1);
Constant *C2 = const_cast<Constant*>(V2);
ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
- R = dyn_cast<ConstantBool>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getValue())
+ R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ if (R && R->getBoolValue())
return pred;
pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
- R = dyn_cast<ConstantBool>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getValue())
+ R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ if (R && R->getBoolValue())
return pred;
pred = isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
- R = dyn_cast<ConstantBool>(ConstantExpr::getICmp(pred, C1, C2));
- if (R && R->getValue())
+ R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, C1, C2));
+ if (R && R->getBoolValue())
return pred;
// If we couldn't figure it out, bail.
@@ -1013,14 +1008,14 @@
// are non-zero then we have a difference, otherwise we are equal.
for (; i < CE1->getNumOperands(); ++i)
if (!CE1->getOperand(i)->isNullValue())
- if (isa<ConstantIntegral>(CE1->getOperand(i)))
+ if (isa<ConstantInt>(CE1->getOperand(i)))
return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT;
else
return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
for (; i < CE2->getNumOperands(); ++i)
if (!CE2->getOperand(i)->isNullValue())
- if (isa<ConstantIntegral>(CE2->getOperand(i)))
+ if (isa<ConstantInt>(CE2->getOperand(i)))
return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
else
return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal.
@@ -1049,34 +1044,35 @@
if (const GlobalValue *GV = dyn_cast<GlobalValue>(C2))
if (!GV->hasExternalWeakLinkage()) // External weak GV can be null
if (pred == ICmpInst::ICMP_EQ)
- return ConstantBool::getFalse();
+ return ConstantInt::getFalse();
else if (pred == ICmpInst::ICMP_NE)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
// icmp eq/ne(GV,null) -> false/true
} else if (C2->isNullValue()) {
if (const GlobalValue *GV = dyn_cast<GlobalValue>(C1))
if (!GV->hasExternalWeakLinkage()) // External weak GV can be null
if (pred == ICmpInst::ICMP_EQ)
- return ConstantBool::getFalse();
+ return ConstantInt::getFalse();
else if (pred == ICmpInst::ICMP_NE)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
}
- if (isa<ConstantBool>(C1) && isa<ConstantBool>(C2)) {
- bool C1Val = cast<ConstantBool>(C1)->getValue();
- bool C2Val = cast<ConstantBool>(C2)->getValue();
+ if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2) &&
+ C1->getType() == Type::BoolTy && C2->getType() == Type::BoolTy) {
+ bool C1Val = cast<ConstantInt>(C1)->getBoolValue();
+ bool C2Val = cast<ConstantInt>(C2)->getBoolValue();
switch (pred) {
default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_EQ: return ConstantBool::get(C1Val == C2Val);
- case ICmpInst::ICMP_NE: return ConstantBool::get(C1Val != C2Val);
- case ICmpInst::ICMP_ULT:return ConstantBool::get(C1Val < C2Val);
- case ICmpInst::ICMP_UGT:return ConstantBool::get(C1Val > C2Val);
- case ICmpInst::ICMP_ULE:return ConstantBool::get(C1Val <= C2Val);
- case ICmpInst::ICMP_UGE:return ConstantBool::get(C1Val >= C2Val);
- case ICmpInst::ICMP_SLT:return ConstantBool::get(C1Val < C2Val);
- case ICmpInst::ICMP_SGT:return ConstantBool::get(C1Val > C2Val);
- case ICmpInst::ICMP_SLE:return ConstantBool::get(C1Val <= C2Val);
- case ICmpInst::ICMP_SGE:return ConstantBool::get(C1Val >= C2Val);
+ 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);
}
} else if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
if (ICmpInst::isSignedPredicate(ICmpInst::Predicate(pred))) {
@@ -1084,22 +1080,22 @@
int64_t V2 = cast<ConstantInt>(C2)->getSExtValue();
switch (pred) {
default: assert(0 && "Invalid ICmp Predicate"); return 0;
- case ICmpInst::ICMP_SLT:return ConstantBool::get(V1 < V2);
- case ICmpInst::ICMP_SGT:return ConstantBool::get(V1 > V2);
- case ICmpInst::ICMP_SLE:return ConstantBool::get(V1 <= V2);
- case ICmpInst::ICMP_SGE:return ConstantBool::get(V1 >= V2);
+ 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);
}
} 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 ConstantBool::get(V1 == V2);
- case ICmpInst::ICMP_NE: return ConstantBool::get(V1 != V2);
- case ICmpInst::ICMP_ULT:return ConstantBool::get(V1 < V2);
- case ICmpInst::ICMP_UGT:return ConstantBool::get(V1 > V2);
- case ICmpInst::ICMP_ULE:return ConstantBool::get(V1 <= V2);
- case ICmpInst::ICMP_UGE:return ConstantBool::get(V1 >= V2);
+ 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);
}
}
} else if (isa<ConstantFP>(C1) && isa<ConstantFP>(C2)) {
@@ -1107,42 +1103,42 @@
double C2Val = cast<ConstantFP>(C2)->getValue();
switch (pred) {
default: assert(0 && "Invalid FCmp Predicate"); return 0;
- case FCmpInst::FCMP_FALSE: return ConstantBool::getFalse();
- case FCmpInst::FCMP_TRUE: return ConstantBool::getTrue();
+ case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse();
+ case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue();
case FCmpInst::FCMP_UNO:
- return ConstantBool::get(C1Val != C1Val || C2Val != C2Val);
+ return ConstantInt::get(C1Val != C1Val || C2Val != C2Val);
case FCmpInst::FCMP_ORD:
- return ConstantBool::get(C1Val == C1Val && C2Val == C2Val);
+ return ConstantInt::get(C1Val == C1Val && C2Val == C2Val);
case FCmpInst::FCMP_UEQ:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OEQ: return ConstantBool::get(C1Val == C2Val);
+ case FCmpInst::FCMP_OEQ: return ConstantInt::get(C1Val == C2Val);
case FCmpInst::FCMP_UNE:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_ONE: return ConstantBool::get(C1Val != C2Val);
+ case FCmpInst::FCMP_ONE: return ConstantInt::get(C1Val != C2Val);
case FCmpInst::FCMP_ULT:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OLT: return ConstantBool::get(C1Val < C2Val);
+ case FCmpInst::FCMP_OLT: return ConstantInt::get(C1Val < C2Val);
case FCmpInst::FCMP_UGT:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OGT: return ConstantBool::get(C1Val > C2Val);
+ case FCmpInst::FCMP_OGT: return ConstantInt::get(C1Val > C2Val);
case FCmpInst::FCMP_ULE:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OLE: return ConstantBool::get(C1Val <= C2Val);
+ case FCmpInst::FCMP_OLE: return ConstantInt::get(C1Val <= C2Val);
case FCmpInst::FCMP_UGE:
if (C1Val != C1Val || C2Val != C2Val)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
/* FALL THROUGH */
- case FCmpInst::FCMP_OGE: return ConstantBool::get(C1Val >= C2Val);
+ case FCmpInst::FCMP_OGE: return ConstantInt::get(C1Val >= C2Val);
}
} else if (const ConstantPacked *CP1 = dyn_cast<ConstantPacked>(C1)) {
if (const ConstantPacked *CP2 = dyn_cast<ConstantPacked>(C2)) {
@@ -1151,7 +1147,7 @@
Constant *C= ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ,
const_cast<Constant*>(CP1->getOperand(i)),
const_cast<Constant*>(CP2->getOperand(i)));
- if (ConstantBool *CB = dyn_cast<ConstantBool>(C))
+ if (ConstantInt *CB = dyn_cast<ConstantInt>(C))
return CB;
}
// Otherwise, could not decide from any element pairs.
@@ -1161,7 +1157,7 @@
Constant *C = ConstantExpr::getICmp(ICmpInst::ICMP_EQ,
const_cast<Constant*>(CP1->getOperand(i)),
const_cast<Constant*>(CP2->getOperand(i)));
- if (ConstantBool *CB = dyn_cast<ConstantBool>(C))
+ if (ConstantInt *CB = dyn_cast<ConstantInt>(C))
return CB;
}
// Otherwise, could not decide from any element pairs.
@@ -1186,40 +1182,40 @@
case FCmpInst::BAD_FCMP_PREDICATE:
break; // Couldn't determine anything about these constants.
case FCmpInst::FCMP_OEQ: // We know that C1 == C2
- return ConstantBool::get(
+ return ConstantInt::get(
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 ConstantBool::get(
+ return ConstantInt::get(
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 ConstantBool::get(
+ return ConstantInt::get(
pred == FCmpInst::FCMP_UNE || pred == FCmpInst::FCMP_ONE ||
pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT ||
pred == FCmpInst::FCMP_UGE || pred == FCmpInst::FCMP_OGE);
case FCmpInst::FCMP_OLE: // We know that C1 <= C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
- return ConstantBool::getFalse();
+ return ConstantInt::getFalse();
if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
break;
case FCmpInst::FCMP_OGE: // We known that C1 >= C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_ULT || pred == FCmpInst::FCMP_OLT)
- return ConstantBool::getFalse();
+ return ConstantInt::getFalse();
if (pred == FCmpInst::FCMP_UGT || pred == FCmpInst::FCMP_OGT)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
break;
case ICmpInst::ICMP_NE: // We know that C1 != C2
// We can only partially decide this relation.
if (pred == FCmpInst::FCMP_OEQ || pred == FCmpInst::FCMP_UEQ)
- return ConstantBool::getFalse();
+ return ConstantInt::getFalse();
if (pred == FCmpInst::FCMP_ONE || pred == FCmpInst::FCMP_UNE)
- return ConstantBool::getTrue();
+ return ConstantInt::getTrue();
break;
}
} else {
@@ -1231,61 +1227,61 @@
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 ConstantBool::get(pred == ICmpInst::ICMP_EQ ||
- pred == ICmpInst::ICMP_ULE ||
- pred == ICmpInst::ICMP_SLE ||
- pred == ICmpInst::ICMP_UGE ||
- pred == ICmpInst::ICMP_SGE);
+ return ConstantInt::get(pred == ICmpInst::ICMP_EQ ||
+ pred == ICmpInst::ICMP_ULE ||
+ pred == ICmpInst::ICMP_SLE ||
+ pred == ICmpInst::ICMP_UGE ||
+ pred == ICmpInst::ICMP_SGE);
case ICmpInst::ICMP_ULT:
// If we know that C1 < C2, we can decide the result of this computation
// precisely.
- return ConstantBool::get(pred == ICmpInst::ICMP_ULT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_ULE);
+ return ConstantInt::get(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 ConstantBool::get(pred == ICmpInst::ICMP_SLT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_SLE);
+ return ConstantInt::get(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 ConstantBool::get(pred == ICmpInst::ICMP_UGT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_UGE);
+ return ConstantInt::get(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 ConstantBool::get(pred == ICmpInst::ICMP_SGT ||
- pred == ICmpInst::ICMP_NE ||
- pred == ICmpInst::ICMP_SGE);
+ return ConstantInt::get(pred == ICmpInst::ICMP_SGT ||
+ pred == ICmpInst::ICMP_NE ||
+ pred == ICmpInst::ICMP_SGE);
case ICmpInst::ICMP_ULE:
// If we know that C1 <= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_UGT) return ConstantBool::getFalse();
- if (pred == ICmpInst::ICMP_ULT) return ConstantBool::getTrue();
+ if (pred == ICmpInst::ICMP_UGT) return ConstantInt::getFalse();
+ if (pred == ICmpInst::ICMP_ULT) return ConstantInt::getTrue();
break;
case ICmpInst::ICMP_SLE:
// If we know that C1 <= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_SGT) return ConstantBool::getFalse();
- if (pred == ICmpInst::ICMP_SLT) return ConstantBool::getTrue();
+ if (pred == ICmpInst::ICMP_SGT) return ConstantInt::getFalse();
+ if (pred == ICmpInst::ICMP_SLT) return ConstantInt::getTrue();
break;
case ICmpInst::ICMP_UGE:
// If we know that C1 >= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_ULT) return ConstantBool::getFalse();
- if (pred == ICmpInst::ICMP_UGT) return ConstantBool::getTrue();
+ if (pred == ICmpInst::ICMP_ULT) return ConstantInt::getFalse();
+ if (pred == ICmpInst::ICMP_UGT) return ConstantInt::getTrue();
break;
case ICmpInst::ICMP_SGE:
// If we know that C1 >= C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_SLT) return ConstantBool::getFalse();
- if (pred == ICmpInst::ICMP_SGT) return ConstantBool::getTrue();
+ if (pred == ICmpInst::ICMP_SLT) return ConstantInt::getFalse();
+ if (pred == ICmpInst::ICMP_SGT) return ConstantInt::getTrue();
break;
case ICmpInst::ICMP_NE:
// If we know that C1 != C2, we can only partially decide this relation.
- if (pred == ICmpInst::ICMP_EQ) return ConstantBool::getFalse();
- if (pred == ICmpInst::ICMP_NE) return ConstantBool::getTrue();
+ if (pred == ICmpInst::ICMP_EQ) return ConstantInt::getFalse();
+ if (pred == ICmpInst::ICMP_NE) return ConstantInt::getTrue();
break;
}
Index: llvm/lib/VMCore/Constants.cpp
diff -u llvm/lib/VMCore/Constants.cpp:1.194 llvm/lib/VMCore/Constants.cpp:1.195
--- llvm/lib/VMCore/Constants.cpp:1.194 Wed Jan 3 19:49:26 2007
+++ llvm/lib/VMCore/Constants.cpp Thu Jan 11 06:24:14 2007
@@ -93,7 +93,7 @@
Constant *Constant::getNullValue(const Type *Ty) {
switch (Ty->getTypeID()) {
case Type::BoolTyID: {
- static Constant *NullBool = ConstantBool::get(false);
+ static Constant *NullBool = ConstantInt::get(false);
return NullBool;
}
case Type::Int8TyID: {
@@ -135,9 +135,9 @@
// Static constructor to create an integral constant with all bits set
-ConstantIntegral *ConstantIntegral::getAllOnesValue(const Type *Ty) {
+ConstantInt *ConstantInt::getAllOnesValue(const Type *Ty) {
switch (Ty->getTypeID()) {
- case Type::BoolTyID: return ConstantBool::getTrue();
+ case Type::BoolTyID: return ConstantInt::getTrue();
case Type::Int8TyID:
case Type::Int16TyID:
case Type::Int32TyID:
@@ -152,7 +152,7 @@
ConstantPacked *ConstantPacked::getAllOnesValue(const PackedType *Ty) {
std::vector<Constant*> Elts;
Elts.resize(Ty->getNumElements(),
- ConstantIntegral::getAllOnesValue(Ty->getElementType()));
+ ConstantInt::getAllOnesValue(Ty->getElementType()));
assert(Elts[0] && "Not a packed integer type!");
return cast<ConstantPacked>(ConstantPacked::get(Elts));
}
@@ -165,16 +165,12 @@
//===----------------------------------------------------------------------===//
// Normal Constructors
-ConstantIntegral::ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V)
- : Constant(Ty, VT, 0, 0), Val(V) {
-}
-
-ConstantBool::ConstantBool(bool V)
- : ConstantIntegral(Type::BoolTy, ConstantBoolVal, uint64_t(V)) {
+ConstantInt::ConstantInt(bool V)
+ : Constant(Type::BoolTy, ConstantIntVal, 0, 0), Val(uint64_t(V)) {
}
ConstantInt::ConstantInt(const Type *Ty, uint64_t V)
- : ConstantIntegral(Ty, ConstantIntVal, V) {
+ : Constant(Ty, ConstantIntVal, 0, 0), Val(Ty == Type::BoolTy ? bool(V) : V) {
}
ConstantFP::ConstantFP(const Type *Ty, double V)
@@ -383,9 +379,9 @@
return get(Instruction::Sub, ConstantFP::get(C->getType(), -0.0), C);
}
Constant *ConstantExpr::getNot(Constant *C) {
- assert(isa<ConstantIntegral>(C) && "Cannot NOT a nonintegral type!");
+ assert(isa<ConstantInt>(C) && "Cannot NOT a nonintegral type!");
return get(Instruction::Xor, C,
- ConstantIntegral::getAllOnesValue(C->getType()));
+ ConstantInt::getAllOnesValue(C->getType()));
}
Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2) {
return get(Instruction::Add, C1, C2);
@@ -555,6 +551,7 @@
bool ConstantInt::isValueValidForType(const Type *Ty, uint64_t Val) {
switch (Ty->getTypeID()) {
default: return false; // These can't be represented as integers!
+ case Type::BoolTyID: return Val == 0 || Val == 1;
case Type::Int8TyID: return Val <= UINT8_MAX;
case Type::Int16TyID: return Val <= UINT16_MAX;
case Type::Int32TyID: return Val <= UINT32_MAX;
@@ -565,6 +562,7 @@
bool ConstantInt::isValueValidForType(const Type *Ty, int64_t Val) {
switch (Ty->getTypeID()) {
default: return false; // These can't be represented as integers!
+ case Type::BoolTyID: return (Val == 0 || Val == 1);
case Type::Int8TyID: return (Val >= INT8_MIN && Val <= INT8_MAX);
case Type::Int16TyID: return (Val >= INT16_MIN && Val <= UINT16_MAX);
case Type::Int32TyID: return (Val >= INT32_MIN && Val <= UINT32_MAX);
@@ -830,19 +828,6 @@
}
-//---- ConstantBool::get*() implementation.
-
-ConstantBool *ConstantBool::getTrue() {
- static ConstantBool *T = 0;
- if (T) return T;
- return T = new ConstantBool(true);
-}
-ConstantBool *ConstantBool::getFalse() {
- static ConstantBool *F = 0;
- if (F) return F;
- return F = new ConstantBool(false);
-}
-
//---- ConstantInt::get() implementations...
//
static ManagedStatic<ValueMap<uint64_t, Type, ConstantInt> > IntConstants;
@@ -853,11 +838,7 @@
// 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) {
- return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
-}
-
-ConstantIntegral *ConstantIntegral::get(const Type *Ty, int64_t V) {
- if (Ty == Type::BoolTy) return ConstantBool::get(V&1);
+ if (Ty == Type::BoolTy) return ConstantInt::get(V&1);
return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
}
Index: llvm/lib/VMCore/Instructions.cpp
diff -u llvm/lib/VMCore/Instructions.cpp:1.58 llvm/lib/VMCore/Instructions.cpp:1.59
--- llvm/lib/VMCore/Instructions.cpp:1.58 Sat Dec 30 23:26:44 2006
+++ llvm/lib/VMCore/Instructions.cpp Thu Jan 11 06:24:14 2007
@@ -1118,10 +1118,10 @@
Instruction *InsertBefore) {
Constant *C;
if (const PackedType *PTy = dyn_cast<PackedType>(Op->getType())) {
- C = ConstantIntegral::getAllOnesValue(PTy->getElementType());
+ C = ConstantInt::getAllOnesValue(PTy->getElementType());
C = ConstantPacked::get(std::vector<Constant*>(PTy->getNumElements(), C));
} else {
- C = ConstantIntegral::getAllOnesValue(Op->getType());
+ C = ConstantInt::getAllOnesValue(Op->getType());
}
return new BinaryOperator(Instruction::Xor, Op, C,
@@ -1133,11 +1133,11 @@
Constant *AllOnes;
if (const PackedType *PTy = dyn_cast<PackedType>(Op->getType())) {
// Create a vector of all ones values.
- Constant *Elt = ConstantIntegral::getAllOnesValue(PTy->getElementType());
+ Constant *Elt = ConstantInt::getAllOnesValue(PTy->getElementType());
AllOnes =
ConstantPacked::get(std::vector<Constant*>(PTy->getNumElements(), Elt));
} else {
- AllOnes = ConstantIntegral::getAllOnesValue(Op->getType());
+ AllOnes = ConstantInt::getAllOnesValue(Op->getType());
}
return new BinaryOperator(Instruction::Xor, Op, AllOnes,
@@ -1147,7 +1147,7 @@
// isConstantAllOnes - Helper function for several functions below
static inline bool isConstantAllOnes(const Value *V) {
- return isa<ConstantIntegral>(V) &&cast<ConstantIntegral>(V)->isAllOnesValue();
+ return isa<ConstantInt>(V) &&cast<ConstantInt>(V)->isAllOnesValue();
}
bool BinaryOperator::isNeg(const Value *V) {
More information about the llvm-commits
mailing list