From: Reid Spencer Date: Fri, 12 Jan 2007 04:24:46 +0000 (+0000) Subject: Implement review feedback for the ConstantBool->ConstantInt merge. Chris X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=579dca12c2cfd60bc18aaadbd5331897d48fec29 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 337a62c5118..dd85b43bc7a 100644 --- a/include/llvm/Constants.h +++ b/include/llvm/Constants.h @@ -85,10 +85,6 @@ public: 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 @@ public: /// @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(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 @@ public: /// 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 @@ public: /// @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 @@ public: /// @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 ebe4cec60e4..d49898a401c 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -586,7 +586,7 @@ BasicAliasAnalysis::CheckGEPInstructions( Constant *Compare = ConstantExpr::getICmp(ICmpInst::ICMP_SGT, G1OC, G2OC); if (ConstantInt *CV = dyn_cast(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 6c2dce03aa5..7a344201dd3 100644 --- a/lib/Analysis/ConstantRange.cpp +++ b/lib/Analysis/ConstantRange.cpp @@ -64,7 +64,7 @@ static ConstantInt *getMinValue(const Type *Ty, bool isSigned = false) { } 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 @@ static bool LT(ConstantInt *A, ConstantInt *B, bool isSigned) { Constant *C = ConstantExpr::getICmp( (isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT), A, B); assert(isa(C) && "Constant folding of integrals not impl??"); - return cast(C)->getBoolValue(); + return cast(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(C) && "Constant folding of integrals not impl??"); - return cast(C)->getBoolValue(); + return cast(C)->getZExtValue(); } static bool GT(ConstantInt *A, ConstantInt *B, bool isSigned) { diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp index ad16acc9b40..27c9e622ca8 100644 --- a/lib/Analysis/ScalarEvolution.cpp +++ b/lib/Analysis/ScalarEvolution.cpp @@ -1722,7 +1722,7 @@ ComputeLoadConstantCompareIterationCount(LoadInst *LI, Constant *RHS, // Evaluate the condition for this iteration. Result = ConstantExpr::getICmp(predicate, Result, RHS); if (!isa(Result)) break; // Couldn't decide for sure - if (cast(Result)->getBoolValue() == false) { + if (cast(Result)->getZExtValue() == false) { #if 0 cerr << "\n***\n*** Computed loop count " << *ItCst << "\n*** From global " << *GV << "*** BB: " << *L->getHeader() @@ -1932,7 +1932,7 @@ ComputeIterationCountExhaustively(const Loop *L, Value *Cond, bool ExitWhen) { // 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 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToZero(SCEV *V, const Loop *L) { if (ConstantInt *CB = dyn_cast(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 @@ SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range, if (ConstantInt *CB = dyn_cast(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 b3869fb773a..787d000c231 100644 --- a/lib/Bytecode/Reader/Reader.cpp +++ b/lib/Bytecode/Reader/Reader.cpp @@ -1403,7 +1403,7 @@ Value *BytecodeReader::ParseConstantPoolValue(unsigned TypeID) { 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 7acd2094c5d..9a044280079 100644 --- a/lib/Bytecode/Writer/Writer.cpp +++ b/lib/Bytecode/Writer/Writer.cpp @@ -322,7 +322,7 @@ void BytecodeWriter::outputConstant(const Constant *CPV) { switch (CPV->getType()->getTypeID()) { case Type::Int1TyID: // Boolean Types - if (cast(CPV)->getBoolValue()) + if (cast(CPV)->getZExtValue()) output_vbr(1U); else output_vbr(0U); diff --git a/lib/CodeGen/AsmPrinter.cpp b/lib/CodeGen/AsmPrinter.cpp index fed85b3e502..d7a134e46df 100644 --- a/lib/CodeGen/AsmPrinter.cpp +++ b/lib/CodeGen/AsmPrinter.cpp @@ -390,7 +390,7 @@ void AsmPrinter::EmitConstantValueOnly(const Constant *CV) { O << "0"; else if (const ConstantInt *CI = dyn_cast(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(CV)) { diff --git a/lib/CodeGen/MachineDebugInfo.cpp b/lib/CodeGen/MachineDebugInfo.cpp index 2ebd64bf350..0a6d3acb9cb 100644 --- a/lib/CodeGen/MachineDebugInfo.cpp +++ b/lib/CodeGen/MachineDebugInfo.cpp @@ -211,7 +211,7 @@ public: } virtual void Apply(bool &Field) { Constant *C = CI->getOperand(I++); - Field = cast(C)->getBoolValue(); + Field = cast(C)->getZExtValue(); } virtual void Apply(std::string &Field) { Constant *C = CI->getOperand(I++); @@ -276,7 +276,7 @@ public: 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 3c388d32f36..e5f9ea1f40e 100644 --- a/lib/ExecutionEngine/ExecutionEngine.cpp +++ b/lib/ExecutionEngine/ExecutionEngine.cpp @@ -399,7 +399,7 @@ GenericValue ExecutionEngine::getConstantValue(const Constant *C) { switch (C->getType()->getTypeID()) { #define GET_CONST_VAL(TY, CTY, CLASS, GETMETH) \ case Type::TY##TyID: Result.TY##Val = (CTY)cast(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 f6ced0a2518..13ee7199d9f 100644 --- a/lib/ExecutionEngine/JIT/JIT.cpp +++ b/lib/ExecutionEngine/JIT/JIT.cpp @@ -191,7 +191,7 @@ GenericValue JIT::runFunction(Function *F, 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 6c2dce03aa5..7a344201dd3 100644 --- a/lib/Support/ConstantRange.cpp +++ b/lib/Support/ConstantRange.cpp @@ -64,7 +64,7 @@ static ConstantInt *getMinValue(const Type *Ty, bool isSigned = false) { } 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 @@ static bool LT(ConstantInt *A, ConstantInt *B, bool isSigned) { Constant *C = ConstantExpr::getICmp( (isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT), A, B); assert(isa(C) && "Constant folding of integrals not impl??"); - return cast(C)->getBoolValue(); + return cast(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(C) && "Constant folding of integrals not impl??"); - return cast(C)->getBoolValue(); + return cast(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 f945036a74b..23465c5f6e4 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -829,7 +829,7 @@ void CWriter::printConstant(Constant *CPV) { if (ConstantInt *CI = dyn_cast(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 ce30477c872..86657c2c0e5 100644 --- a/lib/Transforms/IPO/GlobalOpt.cpp +++ b/lib/Transforms/IPO/GlobalOpt.cpp @@ -1161,7 +1161,7 @@ static void ShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) { // 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 @@ static bool EvaluateFunction(Function *F, Constant *&RetVal, // 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(CurInst)) { ConstantInt *Val = diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp index 5c0aa363610..c0a7a0569b3 100644 --- a/lib/Transforms/Instrumentation/RSProfiling.cpp +++ b/lib/Transforms/Instrumentation/RSProfiling.cpp @@ -460,7 +460,7 @@ void ProfilerRS::ProcessBackEdge(BasicBlock* src, BasicBlock* dst, Function& F) //b: new BranchInst(cast(Translate(dst)), bbC); new BranchInst(dst, cast(Translate(dst)), - ConstantInt::get(true), bbCp); + ConstantInt::get(Type::Int1Ty, true), bbCp); //c: { TerminatorInst* iB = src->getTerminator(); @@ -516,7 +516,7 @@ bool ProfilerRS::runOnFunction(Function& F) { TerminatorInst* T = F.getEntryBlock().getTerminator(); ReplaceInstWithInst(T, new BranchInst(T->getSuccessor(0), cast(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 65e8c8d1ded..253535e3a5e 100644 --- a/lib/Transforms/Scalar/CondPropagate.cpp +++ b/lib/Transforms/Scalar/CondPropagate.cpp @@ -139,7 +139,7 @@ void CondProp::SimplifyPredecessors(BranchInst *BI) { // 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 09d5c070604..00055b45864 100644 --- a/lib/Transforms/Scalar/CorrelatedExprs.cpp +++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp @@ -472,7 +472,7 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo, } else if (CmpInst *CI = dyn_cast(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(*I) && "Unexpected instruction type!"); } @@ -488,7 +488,7 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo, // 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 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { // 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 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { // 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(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(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 @@ void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) { // about the relation into this region as well. // if (ICmpInst *ICI = dyn_cast(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 @@ void CEE::IncorporateInstruction(Instruction *Inst, RegionInfo &RI) { // 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 @@ bool CEE::SimplifyBasicBlock(BasicBlock &BB, const RegionInfo &RI) { 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 @@ Relation::KnownResult CEE::getCmpResult(CmpInst *CI, if (Constant *Result = ConstantFoldInstruction(CI)) { // Wow, this is easy, directly eliminate the ICmpInst. DEBUG(cerr << "Replacing cmp with constant fold: " << *CI); - return cast(Result)->getBoolValue() + return cast(Result)->getZExtValue() ? Relation::KnownTrue : Relation::KnownFalse; } } else { diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index bf4f5f3e235..c039b3999a3 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -2965,7 +2965,7 @@ Instruction *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, bool isSigned, bool Inside, Instruction &IB) { assert(cast(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 @@ Instruction *InstCombiner::visitAnd(BinaryOperator &I) { ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; Constant *Cmp = ConstantExpr::getICmp(GT, LHSCst, RHSCst); ICmpInst *LHS = cast(Op0); - if (cast(Cmp)->getBoolValue()) { + if (cast(Cmp)->getZExtValue()) { std::swap(LHS, RHS); std::swap(LHSCst, RHSCst); std::swap(LHSCC, RHSCC); @@ -3723,7 +3723,7 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) { ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; Constant *Cmp = ConstantExpr::getICmp(GT, LHSCst, RHSCst); ICmpInst *LHS = cast(Op0); - if (cast(Cmp)->getBoolValue()) { + if (cast(Cmp)->getZExtValue()) { std::swap(LHS, RHS); std::swap(LHSCst, RHSCst); std::swap(LHSCC, RHSCC); @@ -4152,7 +4152,8 @@ Instruction *InstCombiner::FoldGEPICmp(User *GEPLHS, Value *RHS, EmitIt = false; // This is indexing into a zero sized array? } else if (isa(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 @@ Instruction *InstCombiner::FoldGEPICmp(User *GEPLHS, Value *RHS, 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 @@ Instruction *InstCombiner::FoldGEPICmp(User *GEPLHS, Value *RHS, 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 @@ Instruction *InstCombiner::visitFCmpInst(FCmpInst &I) { // 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(Op1)) // fcmp pred X, undef -> undef return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty)); @@ -4333,7 +4337,8 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { // icmp X, X if (Op0 == Op1) - return ReplaceInstUsesWith(I, ConstantInt::get(isTrueWhenEqual(I))); + return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty, + isTrueWhenEqual(I))); if (isa(Op1)) // X icmp undef -> undef return ReplaceInstUsesWith(I, UndefValue::get(Type::Int1Ty)); @@ -4343,7 +4348,8 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { if (GlobalValue *GV0 = dyn_cast(Op0)) if (GlobalValue *GV1 = dyn_cast(Op1)) if (!GV0->hasExternalWeakLinkage() || !GV1->hasExternalWeakLinkage()) - return ReplaceInstUsesWith(I, ConstantInt::get(!isTrueWhenEqual(I))); + return ReplaceInstUsesWith(I, ConstantInt::get(Type::Int1Ty, + !isTrueWhenEqual(I))); // icmp , - Global/Stack value // addresses never equal each other! We already know that Op0 != Op1. @@ -4351,7 +4357,8 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { isa(Op0)) && (isa(Op1) || isa(Op1) || isa(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 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { 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 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { 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 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { if (Constant *BOC = dyn_cast(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 @@ Instruction *InstCombiner::visitICmpInst(ICmpInst &I) { // 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 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) { 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 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { // select true, X, Y -> X // select false, X, Y -> Y if (ConstantInt *C = dyn_cast(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 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { ConstantInt *C; if ((C = dyn_cast(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 @@ Instruction *InstCombiner::visitSelectInst(SelectInst &SI) { } } else if ((C = dyn_cast(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 @@ static void AddReachableCodeToWorklist(BasicBlock *BB, if (BranchInst *BI = dyn_cast(TI)) { if (BI->isConditional() && isa(BI->getCondition()) && BI->getCondition()->getType() == Type::Int1Ty) { - bool CondVal = cast(BI->getCondition())->getBoolValue(); + bool CondVal = cast(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 c97c9b5518c..80d4311ebcb 100644 --- a/lib/Transforms/Scalar/LoopUnswitch.cpp +++ b/lib/Transforms/Scalar/LoopUnswitch.cpp @@ -924,7 +924,8 @@ void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC, if (IsEqual) Replacement = Val; else - Replacement = ConstantInt::get(!cast(Val)->getBoolValue()); + Replacement = ConstantInt::get(Type::Int1Ty, + !cast(Val)->getZExtValue()); for (unsigned i = 0, e = Users.size(); i != e; ++i) if (Instruction *U = cast(Users[i])) { @@ -1026,7 +1027,7 @@ void LoopUnswitch::SimplifyCode(std::vector &Worklist) { switch (I->getOpcode()) { case Instruction::Select: if (ConstantInt *CB = dyn_cast(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 @@ void LoopUnswitch::SimplifyCode(std::vector &Worklist) { cast(I)->swapOperands(); if (ConstantInt *CB = dyn_cast(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 @@ void LoopUnswitch::SimplifyCode(std::vector &Worklist) { cast(I)->swapOperands(); if (ConstantInt *CB = dyn_cast(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 @@ void LoopUnswitch::SimplifyCode(std::vector &Worklist) { 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 daf21d43f71..2bc000440ae 100644 --- a/lib/Transforms/Scalar/SCCP.cpp +++ b/lib/Transforms/Scalar/SCCP.cpp @@ -416,8 +416,7 @@ void SCCPSolver::getFeasibleSuccessors(TerminatorInst &TI, } else { LatticeVal &BCValue = getValueState(BI->getCondition()); if (BCValue.isOverdefined() || - (BCValue.isConstant() && - BCValue.getConstant()->getType() != Type::Int1Ty)) { + (BCValue.isConstant() && !isa(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 @@ void SCCPSolver::visitSelectInst(SelectInst &I) { 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(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 cb98dc58e26..753d657d583 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -233,7 +233,7 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB) { // 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 4e8f3c0ec4e..e83f1b02fc6 100644 --- a/lib/Transforms/Utils/CodeExtractor.cpp +++ b/lib/Transforms/Utils/CodeExtractor.cpp @@ -470,7 +470,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer, 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 f3d6ca85ccf..fd24f10de8b 100644 --- a/lib/Transforms/Utils/Local.cpp +++ b/lib/Transforms/Utils/Local.cpp @@ -176,8 +176,8 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB) { if (ConstantInt *Cond = dyn_cast(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 964b47c4efb..25bc16866f3 100644 --- a/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/lib/Transforms/Utils/SimplifyCFG.cpp @@ -975,7 +975,7 @@ static bool FoldCondBranchOnPHI(BranchInst *BI) { // 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 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { 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 @@ bool llvm::SimplifyCFG(BasicBlock *BB) { 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((*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 09f6feed6d3..138ab3520fd 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -440,8 +440,9 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, static std::string Indent = "\n"; if (const ConstantInt *CI = dyn_cast(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(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 85e5992dcf1..1f5aeb35caf 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -317,8 +317,7 @@ Constant *llvm::ConstantFoldSelectInstruction(const Constant *Cond, const Constant *V1, const Constant *V2) { if (const ConstantInt *CB = dyn_cast(Cond)) - if (CB->getType() == Type::Int1Ty) - return const_cast(CB->getBoolValue() ? V1 : V2); + return const_cast(CB->getZExtValue() ? V1 : V2); if (isa(V1)) return const_cast(V2); if (isa(V2)) return const_cast(V1); @@ -560,11 +559,14 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, 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 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, Constant *C2 = const_cast(V2); R = dyn_cast( ConstantExpr::getFCmp(FCmpInst::FCMP_OEQ, C1, C2)); - if (R && R->getBoolValue()) + if (R && R->getZExtValue()) return FCmpInst::FCMP_OEQ; R = dyn_cast( ConstantExpr::getFCmp(FCmpInst::FCMP_OLT, C1, C2)); - if (R && R->getBoolValue()) + if (R && R->getZExtValue()) return FCmpInst::FCMP_OLT; R = dyn_cast( 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 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, Constant *C2 = const_cast(V2); ICmpInst::Predicate pred = ICmpInst::ICMP_EQ; R = dyn_cast(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(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(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 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, if (isa(C1) && isa(C2) && C1->getType() == Type::Int1Ty && C2->getType() == Type::Int1Ty) { - bool C1Val = cast(C1)->getBoolValue(); - bool C2Val = cast(C2)->getBoolValue(); + bool C1Val = cast(C1)->getZExtValue(); + bool C2Val = cast(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(C1) && isa(C2)) { if (ICmpInst::isSignedPredicate(ICmpInst::Predicate(pred))) { @@ -1080,22 +1092,22 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, int64_t V2 = cast(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(C1)->getZExtValue(); uint64_t V2 = cast(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(C1) && isa(C2)) { @@ -1106,39 +1118,45 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, 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(C1)) { if (const ConstantPacked *CP2 = dyn_cast(C2)) { @@ -1182,17 +1200,17 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, 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 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, 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 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, 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 48502903da9..73490912a5f 100644 --- a/lib/VMCore/Constants.cpp +++ b/lib/VMCore/Constants.cpp @@ -93,7 +93,7 @@ bool Constant::canTrap() const { 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 @@ static ManagedStatic > IntConstants; // 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 4e6fe6b3329..1f6cbaf2885 100644 --- a/tools/llvm2cpp/CppWriter.cpp +++ b/tools/llvm2cpp/CppWriter.cpp @@ -671,7 +671,7 @@ void CppWriter::printConstant(const Constant *CV) { if (const ConstantInt *CI = dyn_cast(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() << ");";