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) { _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
