RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-11-26 05:00:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Eliminate ConstantBool::True and ConstantBool::False. Instead, provide

Browse Source 
ConstantBool::getTrue() and ConstantBool::getFalse().


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30666 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2006-09-28 23:36:21 +00:00
parent 47811b76ca
commit 003cbf35f4
3 changed files with 33 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/llvm/Constants.h
View File

@ -125,12 +125,14 @@ public:
class ConstantBool : public ConstantIntegral {
ConstantBool(bool V);
public:
static ConstantBool *True, *False; ///< The True & False values
/// getTrue/getFalse - Return the singleton true/false values.
static ConstantBool *getTrue();
static ConstantBool *getFalse();
/// This method is provided mostly for compatibility with the other
/// ConstantIntegral subclasses.
/// @brief Static factory method for getting a ConstantBool instance.
static ConstantBool *get(bool Value) { return Value ? True : False; }
static ConstantBool *get(bool Value) { return Value ? getTrue() : getFalse();}
/// This method is provided mostly for compatibility with the other
/// ConstantIntegral subclasses.
@ -139,7 +141,9 @@ public:
/// Returns the opposite value of this ConstantBool value.
/// @brief Get inverse value.
inline ConstantBool *inverted() const { return (this==True) ? False : True; }
inline ConstantBool *inverted() const {
return getValue() ? getFalse() : getTrue();
}
/// @returns the value of this ConstantBool
/// @brief return the boolean value of this constant.
@ -147,10 +151,10 @@ public:
/// @see ConstantIntegral for details
/// @brief Implement overrides
virtual bool isNullValue() const { return this == False; }
virtual bool isMaxValue() const { return this == True; }
virtual bool isMinValue() const { return this == False; }
virtual bool isAllOnesValue() const { return this == True; }
virtual bool isNullValue() const { return getValue() == false; }
virtual bool isMaxValue() const { return getValue() == true; }
virtual bool isMinValue() const { return getValue() == false; }
virtual bool isAllOnesValue() const { return getValue() == true; }
/// @brief Methods to support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const ConstantBool *) { return true; }

8
lib/Analysis/ScalarEvolution.cpp
View File

@ -1689,7 +1689,7 @@ ComputeLoadConstantCompareIterationCount(LoadInst *LI, Constant *RHS,
// Evaluate the condition for this iteration.
Result = ConstantExpr::get(SetCCOpcode, Result, RHS);
if (!isa<ConstantBool>(Result)) break; // Couldn't decide for sure
if (Result == ConstantBool::False) {
if (cast<ConstantBool>(Result)->getValue() == false) {
#if 0
std::cerr << "\n***\n*** Computed loop count " << *ItCst
<< "\n*** From global " << *GV << "*** BB: " << *L->getHeader()
@ -2168,7 +2168,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToZero(SCEV *V, const Loop *L) {
if (ConstantBool *CB =
dyn_cast<ConstantBool>(ConstantExpr::getSetLT(R1->getValue(),
R2->getValue()))) {
if (CB != ConstantBool::True)
if (CB->getValue() == 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
@ -2198,7 +2198,7 @@ SCEVHandle ScalarEvolutionsImpl::HowFarToNonZero(SCEV *V, const Loop *L) {
if (SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
Constant *Zero = Constant::getNullValue(C->getValue()->getType());
Constant *NonZero = ConstantExpr::getSetNE(C->getValue(), Zero);
if (NonZero == ConstantBool::True)
if (NonZero == ConstantBool::getTrue())
return getSCEV(Zero);
return UnknownValue; // Otherwise it will loop infinitely.
}
@ -2386,7 +2386,7 @@ SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range) const {
if (ConstantBool *CB =
dyn_cast<ConstantBool>(ConstantExpr::getSetLT(R1->getValue(),
R2->getValue()))) {
if (CB != ConstantBool::True)
if (CB->getValue() == false)
std::swap(R1, R2); // R1 is the minimum root now.
// Make sure the root is not off by one. The returned iteration should

26
lib/VMCore/Constants.cpp
View File

@ -26,10 +26,6 @@
#include <iostream>
using namespace llvm;
ConstantBool *ConstantBool::True = new ConstantBool(true);
ConstantBool *ConstantBool::False = new ConstantBool(false);
//===----------------------------------------------------------------------===//
// Constant Class
//===----------------------------------------------------------------------===//
@ -128,7 +124,7 @@ Constant *Constant::getNullValue(const Type *Ty) {
// Static constructor to create the maximum constant of an integral type...
ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) {
switch (Ty->getTypeID()) {
case Type::BoolTyID: return ConstantBool::True;
case Type::BoolTyID: return ConstantBool::getTrue();
case Type::SByteTyID:
case Type::ShortTyID:
case Type::IntTyID:
@ -152,7 +148,7 @@ ConstantIntegral *ConstantIntegral::getMaxValue(const Type *Ty) {
// Static constructor to create the minimum constant for an integral type...
ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) {
switch (Ty->getTypeID()) {
case Type::BoolTyID: return ConstantBool::False;
case Type::BoolTyID: return ConstantBool::getFalse();
case Type::SByteTyID:
case Type::ShortTyID:
case Type::IntTyID:
@ -176,7 +172,7 @@ ConstantIntegral *ConstantIntegral::getMinValue(const Type *Ty) {
// Static constructor to create an integral constant with all bits set
ConstantIntegral *ConstantIntegral::getAllOnesValue(const Type *Ty) {
switch (Ty->getTypeID()) {
case Type::BoolTyID: return ConstantBool::True;
case Type::BoolTyID: return ConstantBool::getTrue();
case Type::SByteTyID:
case Type::ShortTyID:
case Type::IntTyID:
@ -877,6 +873,20 @@ public:
};
}
//---- 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);
}
//---- ConstantUInt::get() and ConstantSInt::get() implementations...
//
static ManagedStatic<ValueMap< int64_t, Type, ConstantSInt> > SIntConstants;
@ -1380,7 +1390,7 @@ Constant *ConstantExpr::getSignExtend(Constant *C, const Type *Ty) {
C = ConstantExpr::getCast(C, C->getType()->getSignedVersion());
return ConstantExpr::getCast(C, Ty);
} else {
if (C == ConstantBool::True)
if (C == ConstantBool::getTrue())
return ConstantIntegral::getAllOnesValue(Ty);
else
return ConstantIntegral::getNullValue(Ty);