maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

llvm/Support/IntegersSubset.h: Fix whitespace. 

llvm-svn: 159100
This commit is contained in:
NAKAMURA Takumi 2012-06-24 03:48:47 +00:00
parent c8919dd7fd
commit 37d96f0862
1 changed files with 92 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
llvm/include/llvm/Support/IntegersSubset.h
View File

@ -25,7 +25,7 @@
#include "llvm/LLVMContext.h"
namespace llvm {
// The IntItem is a wrapper for APInt.
// 1. It determines sign of integer, it allows to use
// comparison operators >,<,>=,<=, and as result we got shorter and cleaner
@ -33,30 +33,30 @@ namespace llvm {
// 2. It helps to implement PR1255 (case ranges) as a series of small patches.
// 3. Currently we can interpret IntItem both as ConstantInt and as APInt.
// It allows to provide SwitchInst methods that works with ConstantInt for
// non-updated passes. And it allows to use APInt interface for new methods.
// non-updated passes. And it allows to use APInt interface for new methods.
// 4. IntItem can be easily replaced with APInt.
// The set of macros that allows to propagate APInt operators to the IntItem.
// The set of macros that allows to propagate APInt operators to the IntItem.
#define INT_ITEM_DEFINE_COMPARISON(op,func) \
bool operator op (const APInt& RHS) const { \
return getAPIntValue().func(RHS); \
}
#define INT_ITEM_DEFINE_UNARY_OP(op) \
IntItem operator op () const { \
APInt res = op(getAPIntValue()); \
Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
return IntItem(cast<ConstantInt>(NewVal)); \
}
#define INT_ITEM_DEFINE_BINARY_OP(op) \
IntItem operator op (const APInt& RHS) const { \
APInt res = getAPIntValue() op RHS; \
Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
return IntItem(cast<ConstantInt>(NewVal)); \
}
#define INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(op) \
IntItem& operator op (const APInt& RHS) {\
APInt res = getAPIntValue();\
@ -64,8 +64,8 @@ namespace llvm {
Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
ConstantIntVal = cast<ConstantInt>(NewVal); \
return *this; \
}
}
#define INT_ITEM_DEFINE_PREINCDEC(op) \
IntItem& operator op () { \
APInt res = getAPIntValue(); \
@ -73,7 +73,7 @@ namespace llvm {
Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res); \
ConstantIntVal = cast<ConstantInt>(NewVal); \
return *this; \
}
}
#define INT_ITEM_DEFINE_POSTINCDEC(op) \
IntItem& operator op (int) { \
@ -83,12 +83,12 @@ namespace llvm {
OldConstantIntVal = ConstantIntVal; \
ConstantIntVal = cast<ConstantInt>(NewVal); \
return IntItem(OldConstantIntVal); \
}
}
#define INT_ITEM_DEFINE_OP_STANDARD_INT(RetTy, op, IntTy) \
RetTy operator op (IntTy RHS) const { \
return (*this) op APInt(getAPIntValue().getBitWidth(), RHS); \
}
}
class IntItem {
ConstantInt *ConstantIntVal;
@ -100,29 +100,29 @@ class IntItem {
return *APIntVal;
}
public:
IntItem() {}
operator const APInt&() const {
return getAPIntValue();
}
}
// Propagate APInt operators.
// Note, that
// /,/=,>>,>>= are not implemented in APInt.
// <<= is implemented for unsigned RHS, but not implemented for APInt RHS.
INT_ITEM_DEFINE_COMPARISON(<, ult)
INT_ITEM_DEFINE_COMPARISON(>, ugt)
INT_ITEM_DEFINE_COMPARISON(<=, ule)
INT_ITEM_DEFINE_COMPARISON(>=, uge)
INT_ITEM_DEFINE_COMPARISON(==, eq)
INT_ITEM_DEFINE_OP_STANDARD_INT(bool,==,uint64_t)
INT_ITEM_DEFINE_COMPARISON(!=, ne)
INT_ITEM_DEFINE_OP_STANDARD_INT(bool,!=,uint64_t)
INT_ITEM_DEFINE_BINARY_OP(*)
INT_ITEM_DEFINE_BINARY_OP(+)
INT_ITEM_DEFINE_OP_STANDARD_INT(IntItem,+,uint64_t)
@ -133,32 +133,32 @@ public:
INT_ITEM_DEFINE_BINARY_OP(&)
INT_ITEM_DEFINE_BINARY_OP(^)
INT_ITEM_DEFINE_BINARY_OP(|)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(*=)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(+=)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(-=)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(&=)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(^=)
INT_ITEM_DEFINE_ASSIGNMENT_BY_OP(|=)
// Special case for <<=
IntItem& operator <<= (unsigned RHS) {
APInt res = getAPIntValue();
res <<= RHS;
Constant *NewVal = ConstantInt::get(ConstantIntVal->getContext(), res);
ConstantIntVal = cast<ConstantInt>(NewVal);
return *this;
return *this;
}
INT_ITEM_DEFINE_UNARY_OP(-)
INT_ITEM_DEFINE_UNARY_OP(~)
INT_ITEM_DEFINE_PREINCDEC(++)
INT_ITEM_DEFINE_PREINCDEC(--)
// The set of workarounds, since currently we use ConstantInt implemented
// integer.
static IntItem fromConstantInt(const ConstantInt *V) {
return IntItem(V);
}
@ -185,22 +185,22 @@ protected:
bool IsSingleNumber : 1;
public:
typedef IntRange<IntType> self;
typedef IntRange<IntType> self;
typedef std::pair<self, self> SubRes;
IntRange() : IsEmpty(true) {}
IntRange(const self &RHS) :
Low(RHS.Low), High(RHS.High),
IsEmpty(RHS.IsEmpty), IsSingleNumber(RHS.IsSingleNumber) {}
IntRange(const IntType &C) :
Low(C), High(C), IsEmpty(false), IsSingleNumber(true) {}
IntRange(const IntType &L, const IntType &H) : Low(L), High(H),
IsEmpty(false), IsSingleNumber(Low == High) {}
bool isEmpty() const { return IsEmpty; }
bool isSingleNumber() const { return IsSingleNumber; }
const IntType& getLow() const {
assert(!IsEmpty && "Range is empty.");
return Low;
@ -209,7 +209,7 @@ public:
assert(!IsEmpty && "Range is empty.");
return High;
}
bool operator<(const self &RHS) const {
assert(!IsEmpty && "Left range is empty.");
assert(!RHS.IsEmpty && "Right range is empty.");
@ -226,37 +226,37 @@ public:
bool operator==(const self &RHS) const {
assert(!IsEmpty && "Left range is empty.");
assert(!RHS.IsEmpty && "Right range is empty.");
return Low == RHS.Low && High == RHS.High;
return Low == RHS.Low && High == RHS.High;
}
bool operator!=(const self &RHS) const {
return !operator ==(RHS);
return !operator ==(RHS);
}
static bool LessBySize(const self &LHS, const self &RHS) {
return (LHS.High - LHS.Low) < (RHS.High - RHS.Low);
}
bool isInRange(const IntType &IntVal) const {
assert(!IsEmpty && "Range is empty.");
return IntVal >= Low && IntVal <= High;
}
return IntVal >= Low && IntVal <= High;
}
SubRes sub(const self &RHS) const {
SubRes Res;
// RHS is either more global and includes this range or
// if it doesn't intersected with this range.
if (!isInRange(RHS.Low) && !isInRange(RHS.High)) {
// If RHS more global (it is enough to check
// only one border in this case.
if (RHS.isInRange(Low))
return std::make_pair(self(Low, High), self());
return std::make_pair(self(Low, High), self());
return Res;
}
if (Low < RHS.Low) {
Res.first.Low = Low;
IntType NewHigh = RHS.Low;
@ -269,9 +269,9 @@ public:
Res.second.Low = NewLow;
Res.second.High = High;
}
return Res;
return Res;
}
};
};
//===----------------------------------------------------------------------===//
/// IntegersSubsetGeneric - class that implements the subset of integers. It
@ -288,27 +288,27 @@ public:
typedef std::pair<IntTy*, IntTy*> RangeLinkTy;
typedef std::vector<RangeLinkTy> RangeLinksTy;
typedef typename RangeLinksTy::const_iterator RangeLinksConstIt;
typedef IntegersSubsetGeneric<IntTy> self;
protected:
FlatCollectionTy FlatCollection;
RangeLinksTy RangeLinks;
bool IsSingleNumber;
bool IsSingleNumbersOnly;
public:
template<class RangesCollectionTy>
explicit IntegersSubsetGeneric(const RangesCollectionTy& Links) {
assert(Links.size() && "Empty ranges are not allowed.");
// In case of big set of single numbers consumes additional RAM space,
// but allows to avoid additional reallocation.
FlatCollection.reserve(Links.size() * 2);
RangeLinks.reserve(Links.size());
RangeLinks.reserve(Links.size());
IsSingleNumbersOnly = true;
for (typename RangesCollectionTy::const_iterator i = Links.begin(),
e = Links.end(); i != e; ++i) {
@ -324,11 +324,11 @@ public:
}
IsSingleNumber = IsSingleNumbersOnly && RangeLinks.size() == 1;
}
IntegersSubsetGeneric(const self& RHS) {
*this = RHS;
}
self& operator=(const self& RHS) {
FlatCollection.clear();
RangeLinks.clear();
@ -348,9 +348,9 @@ public:
IsSingleNumbersOnly = RHS.IsSingleNumbersOnly;
return *this;
}
typedef IntRange<IntTy> Range;
/// Checks is the given constant satisfies this case. Returns
/// true if it equals to one of contained values or belongs to the one of
/// contained ranges.
@ -361,18 +361,18 @@ public:
return std::find(FlatCollection.begin(),
FlatCollection.end(),
CheckingVal) != FlatCollection.end();
for (unsigned i = 0, e = getNumItems(); i < e; ++i) {
if (RangeLinks[i].first == RangeLinks[i].second) {
if (*RangeLinks[i].first == CheckingVal)
return true;
} else if (*RangeLinks[i].first <= CheckingVal &&
*RangeLinks[i].second >= CheckingVal)
*RangeLinks[i].second >= CheckingVal)
return true;
}
return false;
return false;
}
/// Returns set's item with given index.
Range getItem(unsigned idx) const {
const RangeLinkTy &Link = RangeLinks[idx];
@ -380,29 +380,29 @@ public:
return Range(*Link.first, *Link.second);
else
return Range(*Link.first);
}
}
/// Return number of items (ranges) stored in set.
unsigned getNumItems() const {
return RangeLinks.size();
}
/// Returns true if whole subset contains single element.
bool isSingleNumber() const {
return IsSingleNumber;
}
/// Returns true if whole subset contains only single numbers, no ranges.
bool isSingleNumbersOnly() const {
return IsSingleNumbersOnly;
}
/// Does the same like getItem(idx).isSingleNumber(), but
/// works faster, since we avoid creation of temporary range object.
/// works faster, since we avoid creation of temporary range object.
bool isSingleNumber(unsigned idx) const {
return RangeLinks[idx].first == RangeLinks[idx].second;
}
/// Returns set the size, that equals number of all values + sizes of all
/// ranges.
/// Ranges set is considered as flat numbers collection.
@ -416,18 +416,18 @@ public:
APInt S = High - Low + 1;
sz += S;
}
return sz.getZExtValue();
return sz.getZExtValue();
}
/// Allows to access single value even if it belongs to some range.
/// Ranges set is considered as flat numbers collection.
/// [<1>, <4,8>] is considered as [1,4,5,6,7,8]
/// [<1>, <4,8>] is considered as [1,4,5,6,7,8]
/// For range [<1>, <4,8>] getSingleValue(3) returns 6.
APInt getSingleValue(unsigned idx) const {
APInt sz(((const APInt&)getItem(0).getLow()).getBitWidth(), 0);
for (unsigned i = 0, e = getNumItems(); i != e; ++i) {
const APInt &Low = getItem(i).getLow();
const APInt &High = getItem(i).getHigh();
const APInt &High = getItem(i).getHigh();
APInt S = High - Low + 1;
APInt oldSz = sz;
sz += S;
@ -440,9 +440,9 @@ public:
}
}
assert(0 && "Index exceeds high border.");
return sz;
return sz;
}
/// Does the same as getSingleValue, but works only if subset contains
/// single numbers only.
const IntTy& getSingleNumber(unsigned idx) const {
@ -450,24 +450,24 @@ public:
"contains single numbers only.");
return FlatCollection[idx];
}
};
};
//===----------------------------------------------------------------------===//
/// IntegersSubset - currently is extension of IntegersSubsetGeneric
/// that also supports conversion to/from Constant* object.
class IntegersSubset : public IntegersSubsetGeneric<IntItem> {
typedef IntegersSubsetGeneric<IntItem> ParentTy;
Constant *Holder;
static unsigned getNumItemsFromConstant(Constant *C) {
return cast<ArrayType>(C->getType())->getNumElements();
}
static Range getItemFromConstant(Constant *C, unsigned idx) {
const Constant *CV = C->getAggregateElement(idx);
unsigned NumEls = cast<VectorType>(CV->getType())->getNumElements();
switch (NumEls) {
case 1:
@ -483,9 +483,9 @@ class IntegersSubset : public IntegersSubsetGeneric<IntItem> {
default:
assert(0 && "Only pairs and single numbers are allowed here.");
return Range();
}
}
}
}
std::vector<Range> rangesFromConstant(Constant *C) {
unsigned NumItems = getNumItemsFromConstant(C);
std::vector<Range> r;
@ -494,12 +494,12 @@ class IntegersSubset : public IntegersSubsetGeneric<IntItem> {
r.push_back(getItemFromConstant(C, i));
return r;
}
public:
explicit IntegersSubset(Constant *C) : ParentTy(rangesFromConstant(C)),
Holder(C) {}
template<class RangesCollectionTy>
explicit IntegersSubset(const RangesCollectionTy& Src) : ParentTy(Src) {
std::vector<Constant*> Elts;
@ -519,18 +519,18 @@ public:
r.push_back(R.getLow().toConstantInt());
}
Constant *CV = ConstantVector::get(r);
Elts.push_back(CV);
Elts.push_back(CV);
}
ArrayType *ArrTy =
ArrayType::get(Elts.front()->getType(), (uint64_t)Elts.size());
Holder = ConstantArray::get(ArrTy, Elts);
Holder = ConstantArray::get(ArrTy, Elts);
}
operator Constant*() { return Holder; }
operator const Constant*() const { return Holder; }
Constant *operator->() { return Holder; }
const Constant *operator->() const { return Holder; }
};
};
}