// -----------------------------------------------------------------------------
// Range-related helper functions.
-// The result may be invalid (max < min).
+template <class Config>
+bool TypeImpl<Config>::Limits::IsEmpty() {
+ return this->min > this->max;
+}
+
+
template<class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::Intersect(
+typename TypeImpl<Config>::Limits TypeImpl<Config>::Limits::Intersect(
Limits lhs, Limits rhs) {
DisallowHeapAllocation no_allocation;
Limits result(lhs);
template <class Config>
-bool TypeImpl<Config>::IsEmpty(Limits lim) {
- return lim.min > lim.max;
-}
-
-
-template <class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::Union(Limits lhs,
- Limits rhs) {
+typename TypeImpl<Config>::Limits TypeImpl<Config>::Limits::Union(
+ Limits lhs, Limits rhs) {
DisallowHeapAllocation no_allocation;
- if (IsEmpty(lhs)) return rhs;
- if (IsEmpty(rhs)) return lhs;
+ if (lhs.IsEmpty()) return rhs;
+ if (rhs.IsEmpty()) return lhs;
Limits result(lhs);
if (lhs.min > rhs.min) result.min = rhs.min;
if (lhs.max < rhs.max) result.max = rhs.max;
typename TypeImpl<Config>::RangeType* lhs,
typename TypeImpl<Config>::RangeType* rhs) {
DisallowHeapAllocation no_allocation;
- typename TypeImpl<Config>::Limits lim = Intersect(Limits(lhs), Limits(rhs));
- return lim.min <= lim.max;
+ return !Limits::Intersect(Limits(lhs), Limits(rhs)).IsEmpty();
}
// Deal with bitsets.
result->Set(size++, BitsetType::New(bits, region));
- Limits lims = Limits::Empty(region);
+ Limits lims = Limits::Empty();
size = IntersectAux(type1, type2, result, size, &lims, region);
// If the range is not empty, then insert it into the union and
// remove the number bits from the bitset.
- if (!IsEmpty(lims)) {
+ if (!lims.IsEmpty()) {
size = UpdateRange(RangeType::New(lims, representation, region), result,
size, region);
bitset number_bits = BitsetType::NumberBits(bits);
if (number_bits == BitsetType::kNone) {
- return Limits::Empty(region);
+ return Limits::Empty();
}
return Limits(BitsetType::Min(number_bits), BitsetType::Max(number_bits));
TypeHandle range, TypeHandle bitset, Region* region) {
Limits range_lims(range->AsRange());
Limits bitset_lims = ToLimits(bitset->AsBitset(), region);
- return Intersect(range_lims, bitset_lims);
+ return Limits::Intersect(range_lims, bitset_lims);
}
if (rhs->IsBitset()) {
Limits lim = IntersectRangeAndBitset(lhs, rhs, region);
- if (!IsEmpty(lim)) {
- *lims = Union(lim, *lims);
+ if (!lim.IsEmpty()) {
+ *lims = Limits::Union(lim, *lims);
}
return size;
}
if (rhs->IsClass()) {
- *lims = Union(Limits(lhs->AsRange()), *lims);
+ *lims = Limits::Union(Limits(lhs->AsRange()), *lims);
}
if (rhs->IsConstant() && Contains(lhs->AsRange(), rhs->AsConstant())) {
return AddToUnion(rhs, result, size, region);
}
if (rhs->IsRange()) {
- Limits lim = Intersect(Limits(lhs->AsRange()), Limits(rhs->AsRange()));
- if (!IsEmpty(lim)) {
- *lims = Union(lim, *lims);
+ Limits lim = Limits::Intersect(
+ Limits(lhs->AsRange()), Limits(rhs->AsRange()));
+ if (!lim.IsEmpty()) {
+ *lims = Limits::Union(lim, *lims);
}
}
return size;
RangeType* range1 = type1->GetRange();
RangeType* range2 = type2->GetRange();
if (range1 != NULL && range2 != NULL) {
- Limits lims = Union(Limits(range1), Limits(range2));
+ Limits lims = Limits::Union(Limits(range1), Limits(range2));
RangeHandle union_range = RangeType::New(lims, representation, region);
range = NormalizeRangeAndBitset(union_range, &new_bitset, region);
} else if (range1 != NULL) {
#define RETURN_NAMED_SEMANTIC_TYPE(type, value) \
case SEMANTIC(k##type): return #type;
SEMANTIC_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
+ INTERNAL_BITSET_TYPE_LIST(RETURN_NAMED_SEMANTIC_TYPE)
#undef RETURN_NAMED_SEMANTIC_TYPE
default:
double max;
Limits(double min, double max) : min(min), max(max) {}
explicit Limits(RangeType* range) : min(range->Min()), max(range->Max()) {}
- static Limits Empty(Region* region) { return Limits(1, 0); }
+ bool IsEmpty();
+ static Limits Empty() { return Limits(1, 0); }
+ static Limits Intersect(Limits lhs, Limits rhs);
+ static Limits Union(Limits lhs, Limits rhs);
};
- static bool IsEmpty(Limits lim);
- static Limits Intersect(Limits lhs, Limits rhs);
- static Limits Union(Limits lhs, Limits rhs);
static bool Overlap(RangeType* lhs, RangeType* rhs);
static bool Contains(RangeType* lhs, RangeType* rhs);
static bool Contains(RangeType* range, ConstantType* constant);