machine()->Word64Shl(),
graph()->NewNode(machine()->ChangeInt32ToInt64(), value),
SmiShiftBitsConstant()));
- } else if (NodeProperties::GetBounds(value).upper->Is(Type::Signed31())) {
+ } else if (NodeProperties::GetBounds(value).upper->Is(Type::SignedSmall())) {
return Replace(
graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant()));
}
double rmax = rhs->Max();
if ((lmin >= 0 && rmin >= 0) || (lmax < 0 && rmax < 0)) {
// Xor-ing negative or non-negative values results in a non-negative value.
- return Type::Unsigned31();
+ return Type::NonNegativeSigned32();
}
if ((lmax < 0 && rmin >= 0) || (lmin >= 0 && rmax < 0)) {
// Xor-ing a negative and a non-negative value results in a negative value.
// TODO(jarin) Use a range here.
- return Type::Negative32();
+ return Type::NegativeSigned32();
}
return Type::Signed32();
}
// in the graph. In the current implementation, we are
// increasing the limits to the closest power of two.
Type* Typer::Visitor::Weaken(Type* current_type, Type* previous_type) {
- // If the types have nothing to do with integers, return the types.
- if (!current_type->Maybe(typer_->integer) ||
- !previous_type->Maybe(typer_->integer)) {
- return current_type;
- }
-
- Type* previous_number =
- Type::Intersect(previous_type, typer_->integer, zone());
- Type* current_number = Type::Intersect(current_type, typer_->integer, zone());
- if (!current_number->IsRange() || !previous_number->IsRange()) {
- return current_type;
- }
-
- Type::RangeType* previous = previous_number->AsRange();
- Type::RangeType* current = current_number->AsRange();
-
- double current_min = current->Min()->Number();
- Handle<Object> new_min = current->Min();
-
- // Find the closest lower entry in the list of allowed
- // minima (or negative infinity if there is no such entry).
- if (current_min != previous->Min()->Number()) {
- new_min = typer_->integer->AsRange()->Min();
- for (const auto val : typer_->weaken_min_limits_) {
- if (val->Number() <= current_min) {
- new_min = val;
- break;
+ Type::RangeType* previous = previous_type->GetRange();
+ Type::RangeType* current = current_type->GetRange();
+ if (previous != NULL && current != NULL) {
+ double current_min = current->Min()->Number();
+ Handle<Object> new_min = current->Min();
+
+ // Find the closest lower entry in the list of allowed
+ // minima (or negative infinity if there is no such entry).
+ if (current_min != previous->Min()->Number()) {
+ new_min = typer_->integer->AsRange()->Min();
+ for (const auto val : typer_->weaken_min_limits_) {
+ if (val->Number() <= current_min) {
+ new_min = val;
+ break;
+ }
}
}
- }
- double current_max = current->Max()->Number();
- Handle<Object> new_max = current->Max();
- // Find the closest greater entry in the list of allowed
- // maxima (or infinity if there is no such entry).
- if (current_max != previous->Max()->Number()) {
- new_max = typer_->integer->AsRange()->Max();
- for (const auto val : typer_->weaken_max_limits_) {
- if (val->Number() >= current_max) {
- new_max = val;
- break;
+ double current_max = current->Max()->Number();
+ Handle<Object> new_max = current->Max();
+ // Find the closest greater entry in the list of allowed
+ // maxima (or infinity if there is no such entry).
+ if (current_max != previous->Max()->Number()) {
+ new_max = typer_->integer->AsRange()->Max();
+ for (const auto val : typer_->weaken_max_limits_) {
+ if (val->Number() >= current_max) {
+ new_max = val;
+ break;
+ }
}
}
- }
- return Type::Union(current_type,
- Type::Range(new_min, new_max, typer_->zone()),
- typer_->zone());
+ return Type::Union(current_type,
+ Type::Range(new_min, new_max, typer_->zone()),
+ typer_->zone());
+ }
+ return current_type;
}
// -----------------------------------------------------------------------------
// TypeImpl
-template <class Config>
-typename TypeImpl<Config>::bitset
-TypeImpl<Config>::BitsetType::SignedSmall() {
- return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
-}
-
-
-template <class Config>
-typename TypeImpl<Config>::bitset
-TypeImpl<Config>::BitsetType::UnsignedSmall() {
- return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
-}
-
-
template<class Config>
TypeImpl<Config>* TypeImpl<Config>::cast(typename Config::Base* object) {
TypeImpl* t = static_cast<TypeImpl*>(object);
}
-// static
-i::Isolate* ZoneTypeConfig::isolate(Zone* zone) { return zone->isolate(); }
-
// -----------------------------------------------------------------------------
// HeapTypeConfig
structure->set(i + 1, *x);
}
-// static
-i::Isolate* HeapTypeConfig::isolate(Isolate* isolate) { return isolate; }
} } // namespace v8::internal
#endif // V8_TYPES_INL_H_
Limits result(lhs);
if (lhs.min->Number() < rhs.min->Number()) result.min = rhs.min;
if (lhs.max->Number() > rhs.max->Number()) result.max = rhs.max;
- result.representation = lhs.representation & rhs.representation;
return result;
}
-template <class Config>
-bool TypeImpl<Config>::IsEmpty(Limits lim) {
- return lim.representation == BitsetType::kNone ||
- lim.min->Number() > lim.max->Number();
-}
-
-
-template <class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::Union(Limits lhs,
- Limits rhs) {
+template<class Config>
+typename TypeImpl<Config>::Limits TypeImpl<Config>::Union(
+ Limits lhs, Limits rhs) {
DisallowHeapAllocation no_allocation;
- // Handle the case of empty operand, so that we do not stretch
- // the limits/representations for them.
- if (IsEmpty(lhs)) return rhs;
- if (IsEmpty(rhs)) return lhs;
-
Limits result(lhs);
if (lhs.min->Number() > rhs.min->Number()) result.min = rhs.min;
if (lhs.max->Number() < rhs.max->Number()) result.max = rhs.max;
- result.representation = lhs.representation | rhs.representation;
return result;
}
typename TypeImpl<Config>::RangeType* rhs) {
DisallowHeapAllocation no_allocation;
typename TypeImpl<Config>::Limits lim = Intersect(Limits(lhs), Limits(rhs));
- return lim.min->Number() <= lim.max->Number() &&
- lim.representation != BitsetType::kNone;
+ return lim.min->Number() <= lim.max->Number();
}
typename TypeImpl<Config>::RangeType* lhs,
typename TypeImpl<Config>::RangeType* rhs) {
DisallowHeapAllocation no_allocation;
- return rhs->Bound()->Is(lhs->Bound()) &&
- lhs->Min()->Number() <= rhs->Min()->Number() &&
- rhs->Max()->Number() <= lhs->Max()->Number();
-}
-
-
-template <class Config>
-bool TypeImpl<Config>::Contains(typename TypeImpl<Config>::RangeType* lhs,
- typename TypeImpl<Config>::ConstantType* rhs) {
- DisallowHeapAllocation no_allocation;
- return IsInteger(*rhs->Value()) && rhs->Bound()->Is(lhs->Bound()) &&
- lhs->Min()->Number() <= rhs->Value()->Number() &&
- rhs->Value()->Number() <= lhs->Max()->Number();
+ return lhs->Min()->Number() <= rhs->Min()->Number()
+ && rhs->Max()->Number() <= lhs->Max()->Number();
}
bool TypeImpl<Config>::Contains(
typename TypeImpl<Config>::RangeType* range, i::Object* val) {
DisallowHeapAllocation no_allocation;
- return IsInteger(val) &&
- BitsetType::Is(BitsetType::Lub(val), range->Bound()->AsBitset()) &&
- range->Min()->Number() <= val->Number() &&
- val->Number() <= range->Max()->Number();
+ return IsInteger(val)
+ && range->Min()->Number() <= val->Number()
+ && val->Number() <= range->Max()->Number();
}
return type->AsBitset();
} else if (type->IsUnion()) {
SLOW_DCHECK(type->AsUnion()->Wellformed());
- return type->AsUnion()->Get(0)->BitsetGlb() |
- type->AsUnion()->Get(1)->BitsetGlb(); // Shortcut.
- } else if (type->IsRange()) {
- bitset glb = SEMANTIC(BitsetType::Glb(type->AsRange()->Min()->Number(),
- type->AsRange()->Max()->Number()));
- if (glb == 0) {
- return kNone;
- } else {
- return glb | REPRESENTATION(type->BitsetLub());
- }
- } else {
+ return type->AsUnion()->Get(0)->BitsetGlb(); // Shortcut.
// (The remaining BitsetGlb's are None anyway).
+ } else {
return kNone;
}
}
type->AsClass()->Bound(NULL)->AsBitset();
}
if (type->IsConstant()) return type->AsConstant()->Bound()->AsBitset();
- if (type->IsRange()) return type->AsRange()->Bound()->AsBitset();
+ if (type->IsRange()) return type->AsRange()->BitsetLub();
if (type->IsContext()) return kInternal & kTaggedPointer;
if (type->IsArray()) return kArray;
if (type->IsFunction()) return kOtherObject; // TODO(rossberg): kFunction
}
-// Minimum values of regular numeric bitsets.
-template <class Config>
-const typename TypeImpl<Config>::BitsetType::Boundary
- TypeImpl<Config>::BitsetType::BoundariesArray[] = {
- {kPlainNumber, -V8_INFINITY},
- {kNegative32, kMinInt},
- {kNegative31, -0x40000000},
- {kUnsigned30, 0},
- {kUnsigned31, 0x40000000},
- {kUnsigned32, 0x80000000},
- {kPlainNumber, static_cast<double>(kMaxUInt32) + 1}
-};
-
-
+// Minimum values of regular numeric bitsets when SmiValuesAre31Bits.
template <class Config>
-const typename TypeImpl<Config>::BitsetType::Boundary*
-TypeImpl<Config>::BitsetType::Boundaries() {
- return BoundariesArray;
-}
-
-
+const typename TypeImpl<Config>::BitsetType::BitsetMin
+ TypeImpl<Config>::BitsetType::BitsetMins31[] = {
+ {kOtherNumber, -V8_INFINITY},
+ {kOtherSigned32, kMinInt},
+ {kNegativeSignedSmall, -0x40000000},
+ {kUnsignedSmall, 0},
+ {kOtherUnsigned31, 0x40000000},
+ {kOtherUnsigned32, 0x80000000},
+ {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}};
+
+
+// Minimum values of regular numeric bitsets when SmiValuesAre32Bits.
+// OtherSigned32 and OtherUnsigned31 are empty (see the diagrams in types.h).
template <class Config>
-size_t TypeImpl<Config>::BitsetType::BoundariesSize() {
- // Windows doesn't like arraysize here.
- // return arraysize(BoundariesArray);
- return 7;
-}
+const typename TypeImpl<Config>::BitsetType::BitsetMin
+ TypeImpl<Config>::BitsetType::BitsetMins32[] = {
+ {kOtherNumber, -V8_INFINITY},
+ {kNegativeSignedSmall, kMinInt},
+ {kUnsignedSmall, 0},
+ {kOtherUnsigned32, 0x80000000},
+ {kOtherNumber, static_cast<double>(kMaxUInt32) + 1}};
template<class Config>
TypeImpl<Config>::BitsetType::Lub(double min, double max) {
DisallowHeapAllocation no_allocation;
int lub = kNone;
- const Boundary* mins = Boundaries();
+ const BitsetMin* mins = BitsetMins();
// Make sure the min-max range touches 0, so we are guaranteed no holes
// in unions of valid bitsets.
if (max < -1) max = -1;
if (min > 0) min = 0;
- for (size_t i = 1; i < BoundariesSize(); ++i) {
+ for (size_t i = 1; i < BitsetMinsSize(); ++i) {
if (min < mins[i].min) {
lub |= mins[i-1].bits;
if (max < mins[i].min) return lub;
}
}
- return lub |= mins[BoundariesSize() - 1].bits;
+ return lub |= mins[BitsetMinsSize()-1].bits;
}
-template <class Config>
-typename TypeImpl<Config>::bitset TypeImpl<Config>::BitsetType::NumberBits(
- bitset bits) {
- return SEMANTIC(bits & kPlainNumber);
-}
-
-
-template <class Config>
-void TypeImpl<Config>::BitsetType::CheckNumberBits(bitset bits) {
- // Check that the bitset does not contain any holes in number ranges.
- bitset number_bits = NumberBits(bits);
- if (number_bits != 0) {
- bitset lub = SEMANTIC(Lub(Min(number_bits), Max(number_bits)));
- CHECK(lub == number_bits);
- }
-}
-
-template <class Config>
-typename TypeImpl<Config>::bitset TypeImpl<Config>::BitsetType::Glb(
- double min, double max) {
- DisallowHeapAllocation no_allocation;
- int glb = kNone;
- const Boundary* mins = Boundaries();
-
- // If the range does not touch 0, the bound is empty.
- if (max < -1 || min > 0) return glb;
-
- for (size_t i = 1; i + 1 < BoundariesSize(); ++i) {
- if (min <= mins[i].min) {
- if (max + 1 < mins[i + 1].min) break;
- glb |= mins[i].bits;
- }
- }
- // OtherNumber also contains float numbers, so it can never be
- // in the greatest lower bound. (There is also the small trouble
- // of kOtherNumber having a range hole, which we can conveniently
- // ignore here.)
- return glb & ~(SEMANTIC(kOtherNumber));
-}
-
-
-template <class Config>
+template<class Config>
double TypeImpl<Config>::BitsetType::Min(bitset bits) {
DisallowHeapAllocation no_allocation;
DCHECK(Is(bits, kNumber));
- const Boundary* mins = Boundaries();
+ const BitsetMin* mins = BitsetMins();
bool mz = SEMANTIC(bits & kMinusZero);
- for (size_t i = 0; i < BoundariesSize(); ++i) {
+ for (size_t i = 0; i < BitsetMinsSize(); ++i) {
if (Is(SEMANTIC(mins[i].bits), bits)) {
return mz ? std::min(0.0, mins[i].min) : mins[i].min;
}
double TypeImpl<Config>::BitsetType::Max(bitset bits) {
DisallowHeapAllocation no_allocation;
DCHECK(Is(bits, kNumber));
- const Boundary* mins = Boundaries();
+ const BitsetMin* mins = BitsetMins();
bool mz = SEMANTIC(bits & kMinusZero);
- if (BitsetType::Is(SEMANTIC(mins[BoundariesSize() - 1].bits), bits)) {
+ if (BitsetType::Is(mins[BitsetMinsSize()-1].bits, bits)) {
return +V8_INFINITY;
}
- for (size_t i = BoundariesSize() - 1; i-- > 0;) {
+ for (size_t i = BitsetMinsSize()-1; i-- > 0; ) {
if (Is(SEMANTIC(mins[i].bits), bits)) {
return mz ?
std::max(0.0, mins[i+1].min - 1) : mins[i+1].min - 1;
}
if (that->IsRange()) {
- return (this->IsRange() && Contains(that->AsRange(), this->AsRange())) ||
- (this->IsConstant() &&
- Contains(that->AsRange(), this->AsConstant()));
+ return (this->IsRange() && Contains(that->AsRange(), this->AsRange()))
+ || (this->IsConstant() &&
+ Contains(that->AsRange(), *this->AsConstant()->Value()));
}
if (this->IsRange()) return false;
if (!BitsetType::IsInhabited(this->BitsetLub() & that->BitsetLub()))
return false;
-
- if (this->IsBitset() && that->IsBitset()) return true;
+ if (this->IsBitset() || that->IsBitset()) return true;
if (this->IsClass() != that->IsClass()) return true;
if (this->IsRange()) {
if (that->IsConstant()) {
- return Contains(this->AsRange(), that->AsConstant());
- }
- if (that->IsRange()) {
- return Overlap(this->AsRange(), that->AsRange());
- }
- if (that->IsBitset()) {
- bitset number_bits = BitsetType::NumberBits(that->AsBitset());
- if (number_bits == BitsetType::kNone) {
- return false;
- }
- if ((REPRESENTATION(that->AsBitset()) &
- REPRESENTATION(this->BitsetLub())) == BitsetType::kNone) {
- return false;
- }
- double min = std::max(BitsetType::Min(number_bits), this->Min());
- double max = std::min(BitsetType::Max(number_bits), this->Max());
- return min <= max;
+ return Contains(this->AsRange(), *that->AsConstant()->Value());
}
+ return that->IsRange() && Overlap(this->AsRange(), that->AsRange());
}
if (that->IsRange()) {
- return that->Maybe(this); // This case is handled above.
+ if (this->IsConstant()) {
+ return Contains(that->AsRange(), *this->AsConstant()->Value());
+ }
+ return this->IsRange() && Overlap(this->AsRange(), that->AsRange());
}
- if (this->IsBitset() || that->IsBitset()) return true;
-
return this->SimplyEquals(that);
}
// (even when the first element is not a bitset).
// 4. No element is itself a union.
// 5. No element is a subtype of any other.
- // 6. If there is a range, then the bitset type does not contain
- // plain number bits.
DCHECK(this->Length() >= 2); // (1)
-
- bitset number_bits = this->Get(0)->IsBitset()
- ? BitsetType::NumberBits(this->Get(0)->AsBitset()) : 0;
- USE(number_bits);
-
for (int i = 0; i < this->Length(); ++i) {
if (i != 0) DCHECK(!this->Get(i)->IsBitset()); // (2)
- if (i != 1) DCHECK(!this->Get(i)->IsRange()); // (3)
- DCHECK(!this->Get(i)->IsUnion()); // (4)
+ if (i != 1) DCHECK(!this->Get(i)->IsRange()); // (3)
+ DCHECK(!this->Get(i)->IsUnion()); // (4)
for (int j = 0; j < this->Length(); ++j) {
if (i != j) DCHECK(!this->Get(i)->Is(this->Get(j))); // (5)
}
}
- DCHECK(!this->Get(1)->IsRange() || (number_bits == 0)); // (6)
return true;
}
// Deal with bitsets.
result->Set(size++, BitsetType::New(bits, region));
- // Insert a placeholder for the range.
- result->Set(size++, None(region));
-
- Limits lims = Limits::Empty(region);
- 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)) {
- UpdateRange(RangeType::New(lims, region), result, size, region);
-
- // Remove the number bits.
- bitset number_bits = BitsetType::NumberBits(bits);
- bits &= ~number_bits;
- if (SEMANTIC(bits) == BitsetType::kNone) {
- bits = BitsetType::kNone;
+
+ // Deal with ranges.
+ TypeHandle range = None(region);
+ RangeType* range1 = type1->GetRange();
+ RangeType* range2 = type2->GetRange();
+ if (range1 != NULL && range2 != NULL) {
+ Limits lim = Intersect(Limits(range1), Limits(range2));
+ if (lim.min->Number() <= lim.max->Number()) {
+ range = RangeType::New(lim, region);
}
- result->Set(0, BitsetType::New(bits, region));
}
+ result->Set(size++, range);
+
+ size = IntersectAux(type1, type2, result, size, region);
return NormalizeUnion(result, size);
}
}
-template <class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::ToLimits(bitset bits,
- Region* region) {
- bitset representation = REPRESENTATION(bits);
- bitset number_bits = BitsetType::NumberBits(bits);
-
- if (representation == BitsetType::kNone && number_bits == BitsetType::kNone) {
- return Limits::Empty(region);
- }
-
- double bitset_min = BitsetType::Min(number_bits);
- double bitset_max = BitsetType::Max(number_bits);
-
- // TODO(jarin) Get rid of the heap numbers.
- i::Factory* f = Config::isolate(region)->factory();
-
- return Limits(f->NewNumber(bitset_min), f->NewNumber(bitset_max),
- representation);
-}
-
-
-template <class Config>
-typename TypeImpl<Config>::Limits TypeImpl<Config>::IntersectRangeAndBitset(
- TypeHandle range, TypeHandle bitset, Region* region) {
- Limits range_lims(range->AsRange());
- Limits bitset_lims = ToLimits(bitset->AsBitset(), region);
- return Intersect(range_lims, bitset_lims);
-}
-
-
-template <class Config>
-int TypeImpl<Config>::IntersectAux(TypeHandle lhs, TypeHandle rhs,
- UnionHandle result, int size, Limits* lims,
- Region* region) {
+template<class Config>
+int TypeImpl<Config>::IntersectAux(
+ TypeHandle lhs, TypeHandle rhs,
+ UnionHandle result, int size, Region* region) {
if (lhs->IsUnion()) {
for (int i = 0, n = lhs->AsUnion()->Length(); i < n; ++i) {
- size =
- IntersectAux(lhs->AsUnion()->Get(i), rhs, result, size, lims, region);
+ size = IntersectAux(lhs->AsUnion()->Get(i), rhs, result, size, region);
}
return size;
}
if (rhs->IsUnion()) {
for (int i = 0, n = rhs->AsUnion()->Length(); i < n; ++i) {
- size =
- IntersectAux(lhs, rhs->AsUnion()->Get(i), result, size, lims, region);
+ size = IntersectAux(lhs, rhs->AsUnion()->Get(i), result, size, region);
}
return size;
}
}
if (lhs->IsRange()) {
- if (rhs->IsBitset()) {
- Limits lim = IntersectRangeAndBitset(lhs, rhs, region);
-
- if (!IsEmpty(lim)) {
- *lims = Union(lim, *lims);
- }
- return size;
+ if (rhs->IsBitset() || rhs->IsClass()) {
+ return UpdateRange(
+ Config::template cast<RangeType>(lhs), result, size, region);
}
- if (rhs->IsClass()) {
- *lims = Union(Limits(lhs->AsRange()), *lims);
- }
- if (rhs->IsConstant() && Contains(lhs->AsRange(), rhs->AsConstant())) {
+ if (rhs->IsConstant() &&
+ Contains(lhs->AsRange(), *rhs->AsConstant()->Value())) {
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);
- }
- }
return size;
}
if (rhs->IsRange()) {
- if (lhs->IsBitset()) {
- Limits lim = IntersectRangeAndBitset(rhs, lhs, region);
-
- if (!IsEmpty(lim)) {
- *lims = Union(lim, *lims);
- }
- return size;
- }
- if (lhs->IsClass()) {
- *lims = Union(Limits(rhs->AsRange()), *lims);
+ if (lhs->IsBitset() || lhs->IsClass()) {
+ return UpdateRange(
+ Config::template cast<RangeType>(rhs), result, size, region);
}
- if (lhs->IsConstant() && Contains(rhs->AsRange(), lhs->AsConstant())) {
+ if (lhs->IsConstant() &&
+ Contains(rhs->AsRange(), *lhs->AsConstant()->Value())) {
return AddToUnion(lhs, result, size, region);
}
return size;
}
-// Make sure that we produce a well-formed range and bitset:
-// If the range is non-empty, the number bits in the bitset should be
-// clear. Moreover, if we have a canonical range (such as Signed32(),
-// we want to produce a bitset rather than a range.
-template <class Config>
-typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::NormalizeRangeAndBitset(
- RangeHandle range, bitset* bits, Region* region) {
- // Fast path: If the bitset does not mention numbers, we can just keep the
- // range.
- bitset number_bits = BitsetType::NumberBits(*bits);
- if (number_bits == 0) {
- return range;
- }
-
- // If the range is contained within the bitset, return an empty range
- // (but make sure we take the representation).
- bitset range_lub = range->BitsetLub();
- if (BitsetType::Is(BitsetType::NumberBits(range_lub), *bits)) {
- *bits |= range_lub;
- return None(region);
- }
-
- // Slow path: reconcile the bitset range and the range.
- double bitset_min = BitsetType::Min(number_bits);
- double bitset_max = BitsetType::Max(number_bits);
-
- i::Handle<i::Object> range_min_obj = range->Min();
- i::Handle<i::Object> range_max_obj = range->Max();
- double range_min = range_min_obj->Number();
- double range_max = range_max_obj->Number();
-
- bitset range_representation = REPRESENTATION(range->BitsetLub());
- bitset bits_representation = REPRESENTATION(*bits);
- bitset representation =
- (bits_representation | range_representation) & BitsetType::kNumber;
-
- // Remove the number bits from the bitset, they would just confuse us now.
- *bits &= ~number_bits;
- if (bits_representation == *bits) {
- *bits = BitsetType::kNone;
- }
-
- if (representation == range_representation && range_min <= bitset_min &&
- range_max >= bitset_max) {
- // Bitset is contained within the range, just return the range.
- return range;
- }
-
- if (bitset_min < range_min) {
- range_min_obj = Config::isolate(region)->factory()->NewNumber(bitset_min);
- }
- if (bitset_max > range_max) {
- range_max_obj = Config::isolate(region)->factory()->NewNumber(bitset_max);
- }
- return RangeType::New(range_min_obj, range_max_obj,
- BitsetType::New(representation, region), region);
-}
-
-
template<class Config>
typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Union(
TypeHandle type1, TypeHandle type2, Region* region) {
UnionHandle result = UnionType::New(size, region);
size = 0;
- // Compute the new bitset.
- bitset new_bitset = type1->BitsetGlb() | type2->BitsetGlb();
+ // Deal with bitsets.
+ TypeHandle bits = BitsetType::New(
+ type1->BitsetGlb() | type2->BitsetGlb(), region);
+ result->Set(size++, bits);
// Deal with ranges.
TypeHandle range = None(region);
RangeType* range1 = type1->GetRange();
RangeType* range2 = type2->GetRange();
if (range1 != NULL && range2 != NULL) {
- Limits lims = Union(Limits(range1), Limits(range2));
- RangeHandle union_range = RangeType::New(lims, region);
- range = NormalizeRangeAndBitset(union_range, &new_bitset, region);
+ range = RangeType::New(Union(Limits(range1), Limits(range2)), region);
} else if (range1 != NULL) {
- range = NormalizeRangeAndBitset(handle(range1), &new_bitset, region);
+ range = handle(range1);
} else if (range2 != NULL) {
- range = NormalizeRangeAndBitset(handle(range2), &new_bitset, region);
+ range = handle(range2);
}
- TypeHandle bits = BitsetType::New(new_bitset, region);
- result->Set(size++, bits);
result->Set(size++, range);
size = AddToUnion(type1, result, size, region);
return ConstantType::New(type->AsConstant()->Value(), region);
} else if (type->IsRange()) {
return RangeType::New(
- type->AsRange()->Min(), type->AsRange()->Max(),
- BitsetType::New(REPRESENTATION(type->BitsetLub()), region), region);
+ type->AsRange()->Min(), type->AsRange()->Max(), region);
} else if (type->IsContext()) {
TypeHandle outer = Convert<OtherType>(type->AsContext()->Outer(), region);
return ContextType::New(outer, region);
return;
}
- // clang-format off
static const bitset named_bitsets[] = {
#define BITSET_CONSTANT(type, value) REPRESENTATION(k##type),
- REPRESENTATION_BITSET_TYPE_LIST(BITSET_CONSTANT)
+ REPRESENTATION_BITSET_TYPE_LIST(BITSET_CONSTANT)
#undef BITSET_CONSTANT
#define BITSET_CONSTANT(type, value) SEMANTIC(k##type),
- INTERNAL_BITSET_TYPE_LIST(BITSET_CONSTANT)
- SEMANTIC_BITSET_TYPE_LIST(BITSET_CONSTANT)
+ INTERNAL_BITSET_TYPE_LIST(BITSET_CONSTANT)
+ SEMANTIC_BITSET_TYPE_LIST(BITSET_CONSTANT)
#undef BITSET_CONSTANT
};
- // clang-format on
bool is_first = true;
os << "(";
// -----------------------------------------------------------------------------
// Values for bitset types
-// clang-format off
-
#define MASK_BITSET_TYPE_LIST(V) \
V(Representation, 0xfff00000u) \
V(Semantic, 0x000ffffeu)
V(OtherNumber, 1u << 4 | REPRESENTATION(kTagged | kUntaggedNumber))
#define SEMANTIC_BITSET_TYPE_LIST(V) \
- V(Negative31, 1u << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \
+ V(NegativeSignedSmall, 1u << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \
V(Null, 1u << 6 | REPRESENTATION(kTaggedPointer)) \
V(Undefined, 1u << 7 | REPRESENTATION(kTaggedPointer)) \
V(Boolean, 1u << 8 | REPRESENTATION(kTaggedPointer)) \
- V(Unsigned30, 1u << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \
+ V(UnsignedSmall, 1u << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \
V(MinusZero, 1u << 10 | REPRESENTATION(kTagged | kUntaggedNumber)) \
V(NaN, 1u << 11 | REPRESENTATION(kTagged | kUntaggedNumber)) \
V(Symbol, 1u << 12 | REPRESENTATION(kTaggedPointer)) \
V(Proxy, 1u << 18 | REPRESENTATION(kTaggedPointer)) \
V(Internal, 1u << 19 | REPRESENTATION(kTagged | kUntagged)) \
\
- V(Signed31, kUnsigned30 | kNegative31) \
- V(Signed32, kSigned31 | kOtherUnsigned31 | kOtherSigned32) \
- V(Negative32, kNegative31 | kOtherSigned32) \
- V(Unsigned31, kUnsigned30 | kOtherUnsigned31) \
- V(Unsigned32, kUnsigned30 | kOtherUnsigned31 | kOtherUnsigned32) \
+ V(SignedSmall, kUnsignedSmall | kNegativeSignedSmall) \
+ V(Signed32, kSignedSmall | kOtherUnsigned31 | kOtherSigned32) \
+ V(NegativeSigned32, kNegativeSignedSmall | kOtherSigned32) \
+ V(NonNegativeSigned32, kUnsignedSmall | kOtherUnsigned31) \
+ V(Unsigned32, kUnsignedSmall | kOtherUnsigned31 | kOtherUnsigned32) \
V(Integral32, kSigned32 | kUnsigned32) \
V(PlainNumber, kIntegral32 | kOtherNumber) \
V(OrderedNumber, kPlainNumber | kMinusZero) \
V(NonNumber, kUnique | kString | kInternal) \
V(Any, 0xfffffffeu)
-// clang-format on
/*
* The following diagrams show how integers (in the mathematical sense) are
* divided among the different atomic numerical types.
*
- * ON OS32 N31 U30 OU31 OU32 ON
+ * If SmiValuesAre31Bits():
+ *
+ * ON OS32 OSS US OU31 OU32 ON
* ______[_______[_______[_______[_______[_______[_______
* -2^31 -2^30 0 2^30 2^31 2^32
*
+ * Otherwise:
+ *
+ * ON OSS US OU32 ON
+ * ______[_______________[_______________[_______[_______
+ * -2^31 0 2^31 2^32
+ *
+ *
* E.g., OtherUnsigned32 (OU32) covers all integers from 2^31 to 2^32-1.
+ *
+ * NOTE: OtherSigned32 (OS32) and OU31 (OtherUnsigned31) are empty if Smis are
+ * 32-bit wide. They should thus never be used directly, only indirectly
+ * via e.g. Number.
*/
#define PROPER_BITSET_TYPE_LIST(V) \
// static i::Handle<V> struct_get_value(Handle<Struct>::type, int);
// template<class V>
// static void struct_set_value(Handle<Struct>::type, int, i::Handle<V>);
-// static i::Isolate* isolate(Region* region);
// }
template<class Config>
class TypeImpl : public Config::Base {
PROPER_BITSET_TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR)
#undef DEFINE_TYPE_CONSTRUCTOR
- static TypeImpl* SignedSmall() {
- return BitsetType::New(BitsetType::SignedSmall());
- }
- static TypeHandle SignedSmall(Region* region) {
- return BitsetType::New(BitsetType::SignedSmall(), region);
- }
- static TypeImpl* UnsignedSmall() {
- return BitsetType::New(BitsetType::UnsignedSmall());
- }
- static TypeHandle UnsignedSmall(Region* region) {
- return BitsetType::New(BitsetType::UnsignedSmall(), region);
- }
-
static TypeHandle Class(i::Handle<i::Map> map, Region* region) {
return ClassType::New(map, region);
}
}
static TypeHandle Range(
i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) {
- return RangeType::New(
- min, max, BitsetType::New(REPRESENTATION(BitsetType::kTagged |
- BitsetType::kUntaggedNumber),
- region),
- region);
+ return RangeType::New(min, max, region);
}
static TypeHandle Context(TypeHandle outer, Region* region) {
return ContextType::New(outer, region);
struct Limits {
i::Handle<i::Object> min;
i::Handle<i::Object> max;
- bitset representation;
- Limits(i::Handle<i::Object> min, i::Handle<i::Object> max,
- bitset representation)
- : min(min), max(max), representation(representation) {}
- explicit Limits(RangeType* range)
- : min(range->Min()),
- max(range->Max()),
- representation(REPRESENTATION(range->Bound()->AsBitset())) {}
- static Limits Empty(Region* region) {
- i::Factory* f = Config::isolate(region)->factory();
- i::Handle<i::Object> min = f->NewNumber(1);
- i::Handle<i::Object> max = f->NewNumber(0);
- return Limits(min, max, BitsetType::kNone);
- }
+ Limits(i::Handle<i::Object> min, i::Handle<i::Object> max) :
+ min(min), max(max) {}
+ explicit Limits(RangeType* range) :
+ min(range->Min()), max(range->Max()) {}
};
- 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);
static bool Contains(RangeType* range, i::Object* val);
static int UpdateRange(
RangeHandle type, UnionHandle result, int size, Region* region);
- static Limits IntersectRangeAndBitset(TypeHandle range, TypeHandle bits,
- Region* region);
- static Limits ToLimits(bitset bits, Region* region);
-
bool SimplyEquals(TypeImpl* that);
template<class TypeHandle>
bool SimplyEquals(TypeHandle that) { return this->SimplyEquals(*that); }
static int AddToUnion(
TypeHandle type, UnionHandle result, int size, Region* region);
- static int IntersectAux(TypeHandle type, TypeHandle other, UnionHandle result,
- int size, Limits* limits, Region* region);
+ static int IntersectAux(
+ TypeHandle type, TypeHandle other,
+ UnionHandle result, int size, Region* region);
static TypeHandle NormalizeUnion(UnionHandle unioned, int size);
- static TypeHandle NormalizeRangeAndBitset(RangeHandle range, bitset* bits,
- Region* region);
};
kUnusedEOL = 0
};
- static bitset SignedSmall();
- static bitset UnsignedSmall();
-
bitset Bitset() { return Config::as_bitset(this); }
static TypeImpl* New(bitset bits) {
- if (FLAG_enable_slow_asserts) CheckNumberBits(bits);
+ DCHECK(bits == kNone || IsInhabited(bits));
+
+ if (FLAG_enable_slow_asserts) {
+ // Check that the bitset does not contain any holes in number ranges.
+ bitset mask = kSemantic;
+ if (!i::SmiValuesAre31Bits()) {
+ mask &= ~(kOtherUnsigned31 | kOtherSigned32);
+ }
+ bitset number_bits = bits & kPlainNumber & mask;
+ if (number_bits != 0) {
+ bitset lub = Lub(Min(number_bits), Max(number_bits)) & mask;
+ CHECK(lub == number_bits);
+ }
+ }
+
return Config::from_bitset(bits);
}
static TypeHandle New(bitset bits, Region* region) {
- if (FLAG_enable_slow_asserts) CheckNumberBits(bits);
+ DCHECK(bits == kNone || IsInhabited(bits));
return Config::from_bitset(bits, region);
}
// TODO(neis): Eventually allow again for types with empty semantics
static double Max(bitset);
static bitset Glb(TypeImpl* type); // greatest lower bound that's a bitset
- static bitset Glb(double min, double max);
static bitset Lub(TypeImpl* type); // least upper bound that's a bitset
static bitset Lub(i::Map* map);
static bitset Lub(i::Object* value);
static void Print(bitset);
#endif
- static bitset NumberBits(bitset bits);
-
private:
- struct Boundary {
+ struct BitsetMin{
bitset bits;
double min;
};
- static const Boundary BoundariesArray[];
- static inline const Boundary* Boundaries();
- static inline size_t BoundariesSize();
-
- static void CheckNumberBits(bitset bits);
+ static const BitsetMin BitsetMins31[];
+ static const BitsetMin BitsetMins32[];
+ static const BitsetMin* BitsetMins() {
+ return i::SmiValuesAre31Bits() ? BitsetMins31 : BitsetMins32;
+ }
+ static size_t BitsetMinsSize() {
+ return i::SmiValuesAre31Bits() ? 7 : 5;
+ /* arraysize(BitsetMins31) : arraysize(BitsetMins32); */
+ // Using arraysize here doesn't compile on Windows.
+ }
};
template<class Config>
class TypeImpl<Config>::RangeType : public StructuralType {
public:
- TypeHandle Bound() { return this->Get(0); }
+ int BitsetLub() { return this->Get(0)->AsBitset(); }
i::Handle<i::Object> Min() { return this->template GetValue<i::Object>(1); }
i::Handle<i::Object> Max() { return this->template GetValue<i::Object>(2); }
- static RangeHandle New(i::Handle<i::Object> min, i::Handle<i::Object> max,
- TypeHandle representation, Region* region) {
+ static RangeHandle New(
+ i::Handle<i::Object> min, i::Handle<i::Object> max, Region* region) {
DCHECK(IsInteger(min->Number()) && IsInteger(max->Number()));
DCHECK(min->Number() <= max->Number());
- bitset representation_bits = representation->AsBitset();
- DCHECK(REPRESENTATION(representation_bits) == representation_bits);
-
RangeHandle type = Config::template cast<RangeType>(
StructuralType::New(StructuralType::kRangeTag, 3, region));
-
- bitset bits = SEMANTIC(BitsetType::Lub(min->Number(), max->Number())) |
- representation_bits;
- type->Set(0, BitsetType::New(bits, region));
+ type->Set(0, BitsetType::New(
+ BitsetType::Lub(min->Number(), max->Number()), region));
type->SetValue(1, min);
type->SetValue(2, max);
return type;
}
static RangeHandle New(Limits lim, Region* region) {
- return New(lim.min, lim.max, BitsetType::New(lim.representation, region),
- region);
+ return New(lim.min, lim.max, region);
}
static RangeType* cast(TypeImpl* type) {
static inline i::Handle<V> struct_get_value(Struct* structure, int i);
template<class V> static inline void struct_set_value(
Struct* structure, int i, i::Handle<V> x);
- static inline i::Isolate* isolate(Zone* zone);
};
typedef TypeImpl<ZoneTypeConfig> Type;
template<class V>
static inline void struct_set_value(
i::Handle<Struct> structure, int i, i::Handle<V> x);
- static inline i::Isolate* isolate(Isolate* isolate);
};
typedef TypeImpl<HeapTypeConfig> HeapType;
Type::String()};
-static Type* kInt32Types[] = {Type::UnsignedSmall(), Type::Negative32(),
- Type::Unsigned31(), Type::SignedSmall(),
- Type::Signed32(), Type::Unsigned32(),
- Type::Integral32()};
+static Type* kInt32Types[] = {
+ Type::UnsignedSmall(), Type::NegativeSigned32(),
+ Type::NonNegativeSigned32(), Type::SignedSmall(),
+ Type::Signed32(), Type::Unsigned32(),
+ Type::Integral32()};
static Type* kNumberTypes[] = {
- Type::UnsignedSmall(), Type::Negative32(), Type::Unsigned31(),
- Type::SignedSmall(), Type::Signed32(), Type::Unsigned32(),
- Type::Integral32(), Type::MinusZero(), Type::NaN(),
- Type::OrderedNumber(), Type::PlainNumber(), Type::Number()};
+ Type::UnsignedSmall(), Type::NegativeSigned32(),
+ Type::NonNegativeSigned32(), Type::SignedSmall(),
+ Type::Signed32(), Type::Unsigned32(),
+ Type::Integral32(), Type::MinusZero(),
+ Type::NaN(), Type::OrderedNumber(),
+ Type::PlainNumber(), Type::Number()};
static Type* kJSTypes[] = {Type::Undefined(), Type::Null(), Type::Boolean(),
TEST(Int32BitwiseShifts) {
JSBitwiseShiftTypedLoweringTester R;
- Type* types[] = {
- Type::SignedSmall(), Type::UnsignedSmall(), Type::Negative32(),
- Type::Unsigned31(), Type::Unsigned32(), Type::Signed32(),
- Type::MinusZero(), Type::NaN(), Type::Undefined(),
- Type::Null(), Type::Boolean(), Type::Number(),
- Type::PlainNumber(), Type::String()};
+ Type* types[] = {Type::SignedSmall(), Type::UnsignedSmall(),
+ Type::NegativeSigned32(), Type::NonNegativeSigned32(),
+ Type::Unsigned32(), Type::Signed32(),
+ Type::MinusZero(), Type::NaN(),
+ Type::Undefined(), Type::Null(),
+ Type::Boolean(), Type::Number(),
+ Type::PlainNumber(), Type::String()};
for (size_t i = 0; i < arraysize(types); ++i) {
Node* p0 = R.Parameter(types[i], 0);
}
}
- void CheckSubOrEqual(TypeHandle type1, TypeHandle type2) {
- CHECK(type1->Is(type2));
- if (this->IsBitset(type1) && this->IsBitset(type2)) {
- CHECK((this->AsBitset(type1) | this->AsBitset(type2))
- == this->AsBitset(type2));
- }
- }
-
void CheckUnordered(TypeHandle type1, TypeHandle type2) {
CHECK(!type1->Is(type2));
CHECK(!type2->Is(type1));
CHECK(T.Constant(fac->NewNumber(0))->Is(T.UnsignedSmall));
CHECK(T.Constant(fac->NewNumber(1))->Is(T.UnsignedSmall));
CHECK(T.Constant(fac->NewNumber(0x3fffffff))->Is(T.UnsignedSmall));
- CHECK(T.Constant(fac->NewNumber(-1))->Is(T.Negative31));
- CHECK(T.Constant(fac->NewNumber(-0x3fffffff))->Is(T.Negative31));
- CHECK(T.Constant(fac->NewNumber(-0x40000000))->Is(T.Negative31));
- CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.Unsigned31));
- CHECK(!T.Constant(fac->NewNumber(0x40000000))->Is(T.Unsigned30));
- CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned31));
- CHECK(!T.Constant(fac->NewNumber(0x7fffffff))->Is(T.Unsigned30));
- CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.Negative32));
- CHECK(!T.Constant(fac->NewNumber(-0x40000001))->Is(T.Negative31));
- CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.Negative32));
- CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.Negative31));
+ CHECK(T.Constant(fac->NewNumber(-1))->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x3fffffff))->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x40000000))->Is(T.NegativeSignedSmall));
if (SmiValuesAre31Bits()) {
+ CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.NonNegativeSigned32));
CHECK(!T.Constant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
+ CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.NonNegativeSigned32));
CHECK(!T.Constant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
- CHECK(!T.Constant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
- CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.NegativeSigned32));
+ CHECK(
+ !T.Constant(fac->NewNumber(-0x40000001))->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.NegativeSigned32));
+ CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 1))
+ ->Is(T.NegativeSignedSmall));
} else {
CHECK(SmiValuesAre32Bits());
CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.UnsignedSmall));
CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.UnsignedSmall));
- CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.SignedSmall));
- CHECK(T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.SignedSmall));
+ CHECK(T.Constant(fac->NewNumber(0x40000000))->Is(T.NonNegativeSigned32));
+ CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.NonNegativeSigned32));
+ CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x7fffffff - 1))
+ ->Is(T.NegativeSignedSmall));
+ CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.NegativeSigned32));
+ CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.NegativeSigned32));
+ CHECK(
+ T.Constant(fac->NewNumber(-0x7fffffff - 1))->Is(T.NegativeSigned32));
}
CHECK(T.Constant(fac->NewNumber(0x80000000u))->Is(T.Unsigned32));
- CHECK(!T.Constant(fac->NewNumber(0x80000000u))->Is(T.Unsigned31));
+ CHECK(!T.Constant(fac->NewNumber(0x80000000u))->Is(T.NonNegativeSigned32));
CHECK(T.Constant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned32));
- CHECK(!T.Constant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned31));
+ CHECK(!T.Constant(fac->NewNumber(0xffffffffu))->Is(T.NonNegativeSigned32));
CHECK(T.Constant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.PlainNumber));
CHECK(!T.Constant(fac->NewNumber(0xffffffffu + 1.0))->Is(T.Integral32));
CHECK(T.Constant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.PlainNumber));
(type1->IsClass() && type2->IsClass()) ||
(type1->IsConstant() && type2->IsConstant()) ||
(type1->IsConstant() && type2->IsRange()) ||
- (this->IsBitset(type1) && type2->IsRange()) ||
(type1->IsRange() && type2->IsRange()) ||
(type1->IsContext() && type2->IsContext()) ||
(type1->IsArray() && type2->IsArray()) ||
CheckSub(T.SignedSmall, T.Number);
CheckSub(T.Signed32, T.Number);
- CheckSubOrEqual(T.SignedSmall, T.Signed32);
+ CheckSub(T.SignedSmall, T.Signed32);
CheckUnordered(T.SignedSmall, T.MinusZero);
CheckUnordered(T.Signed32, T.Unsigned32);
CheckDisjoint(T.Union(T.NumberFunction1, T.String), T.Number);
// Bitset-class
- CheckSub(T.Union(T.ObjectClass, T.SignedSmall),
- T.Union(T.Object, T.Number));
+ CheckSub(
+ T.Union(T.ObjectClass, T.SignedSmall), T.Union(T.Object, T.Number));
CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
T.Union(T.ObjectConstant2, T.ObjectConstant1),
T.Union(T.ObjectConstant1, T.ObjectConstant2)),
T.Union(T.ObjectConstant2, T.ObjectConstant1));
- CheckEqual(T.Union(T.Union(T.Number, T.ArrayClass),
- T.Union(T.SignedSmall, T.Array)),
- T.Union(T.Number, T.Array));
+ CheckEqual(
+ T.Union(
+ T.Union(T.Number, T.ArrayClass),
+ T.Union(T.SignedSmall, T.Array)),
+ T.Union(T.Number, T.Array));
}
void Intersect() {
->IsInhabited()); // !!!
// Union-union
- CheckEqual(T.Intersect(T.Union(T.Number, T.ArrayClass),
- T.Union(T.SignedSmall, T.Array)),
- T.Union(T.SignedSmall, T.ArrayClass));
+ CheckEqual(
+ T.Intersect(
+ T.Union(T.Number, T.ArrayClass),
+ T.Union(T.SignedSmall, T.Array)),
+ T.Union(T.SignedSmall, T.ArrayClass));
CheckEqual(
T.Intersect(
T.Union(T.Number, T.ObjectClass),
PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
#undef DECLARE_TYPE
- SignedSmall = Type::SignedSmall(region);
- UnsignedSmall = Type::UnsignedSmall(region);
-
object_map = isolate->factory()->NewMap(
JS_OBJECT_TYPE, JSObject::kHeaderSize);
array_map = isolate->factory()->NewMap(
#define DECLARE_TYPE(name, value) TypeHandle name;
PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
#undef DECLARE_TYPE
- TypeHandle SignedSmall;
- TypeHandle UnsignedSmall;
TypeHandle ObjectClass;
TypeHandle ArrayClass;
TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTaggedSmall) {
Node* val = Parameter(0);
Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
- NodeProperties::SetBounds(val, Bounds(Type::None(), Type::Signed31()));
+ NodeProperties::SetBounds(val, Bounds(Type::None(), Type::SignedSmall()));
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
// TODO(mstarzinger): Find a common place and unify with test-js-typed-lowering.
Type* const kNumberTypes[] = {
- Type::UnsignedSmall(), Type::Negative32(), Type::Unsigned31(),
- Type::SignedSmall(), Type::Signed32(), Type::Unsigned32(),
- Type::Integral32(), Type::MinusZero(), Type::NaN(),
- Type::OrderedNumber(), Type::PlainNumber(), Type::Number()};
+ Type::UnsignedSmall(), Type::NegativeSigned32(),
+ Type::NonNegativeSigned32(), Type::SignedSmall(),
+ Type::Signed32(), Type::Unsigned32(),
+ Type::Integral32(), Type::MinusZero(),
+ Type::NaN(), Type::OrderedNumber(),
+ Type::PlainNumber(), Type::Number()};
} // namespace
projects / platform / upstream / v8.git / commitdiff