From c44a69d985aae2eea6946af4cdd1fb3d9d6e429a Mon Sep 17 00:00:00 2001 From: "ulan@chromium.org" Date: Fri, 12 Sep 2014 16:13:05 +0000 Subject: [PATCH] Revert r23916, r23917 for breaking 64-bit tests. "Use unsigned type bitsets to limit undefined behaviour". TBR=rossberg@chromium.org Review URL: https://codereview.chromium.org/563283003 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23922 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/types-inl.h | 25 +++---- src/types.cc | 109 +++++++++++++-------------- src/types.h | 152 +++++++++++++++++++------------------- test/cctest/test-types.cc | 44 +++++------ 4 files changed, 156 insertions(+), 174 deletions(-) diff --git a/src/types-inl.h b/src/types-inl.h index 9e16fdf187..f102ae3e13 100644 --- a/src/types-inl.h +++ b/src/types-inl.h @@ -70,7 +70,7 @@ T* ZoneTypeConfig::cast(Type* type) { // static bool ZoneTypeConfig::is_bitset(Type* type) { - return reinterpret_cast(type) & 1; + return reinterpret_cast(type) & 1; } @@ -87,9 +87,9 @@ bool ZoneTypeConfig::is_class(Type* type) { // static -ZoneTypeConfig::Type::bitset ZoneTypeConfig::as_bitset(Type* type) { +int ZoneTypeConfig::as_bitset(Type* type) { DCHECK(is_bitset(type)); - return reinterpret_cast(type) ^ 1u; + return static_cast(reinterpret_cast(type) >> 1); } @@ -108,14 +108,13 @@ i::Handle ZoneTypeConfig::as_class(Type* type) { // static -ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(Type::bitset bitset) { - return reinterpret_cast(bitset | 1u); +ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset) { + return reinterpret_cast((bitset << 1) | 1); } // static -ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset( - Type::bitset bitset, Zone* Zone) { +ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset, Zone* Zone) { return from_bitset(bitset); } @@ -230,9 +229,8 @@ bool HeapTypeConfig::is_struct(Type* type, int tag) { // static -HeapTypeConfig::Type::bitset HeapTypeConfig::as_bitset(Type* type) { - // TODO(rossberg): Breaks the Smi abstraction. Fix once there is a better way. - return reinterpret_cast(type); +int HeapTypeConfig::as_bitset(Type* type) { + return i::Smi::cast(type)->value(); } @@ -249,15 +247,14 @@ i::Handle HeapTypeConfig::as_struct(Type* type) { // static -HeapTypeConfig::Type* HeapTypeConfig::from_bitset(Type::bitset bitset) { - // TODO(rossberg): Breaks the Smi abstraction. Fix once there is a better way. - return reinterpret_cast(bitset); +HeapTypeConfig::Type* HeapTypeConfig::from_bitset(int bitset) { + return Type::cast(i::Smi::FromInt(bitset)); } // static i::Handle HeapTypeConfig::from_bitset( - Type::bitset bitset, Isolate* isolate) { + int bitset, Isolate* isolate) { return i::handle(from_bitset(bitset), isolate); } diff --git a/src/types.cc b/src/types.cc index 16696ea282..af45fa41cb 100644 --- a/src/types.cc +++ b/src/types.cc @@ -30,8 +30,7 @@ static bool deq(double x, double y) { // The largest bitset subsumed by this type. template -typename TypeImpl::bitset -TypeImpl::BitsetType::Glb(TypeImpl* type) { +int TypeImpl::BitsetType::Glb(TypeImpl* type) { DisallowHeapAllocation no_allocation; if (type->IsBitset()) { return type->AsBitset(); @@ -47,18 +46,17 @@ TypeImpl::BitsetType::Glb(TypeImpl* type) { // The smallest bitset subsuming this type. template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(TypeImpl* type) { +int TypeImpl::BitsetType::Lub(TypeImpl* type) { DisallowHeapAllocation no_allocation; if (type->IsBitset()) { return type->AsBitset(); } else if (type->IsUnion()) { UnionHandle unioned = handle(type->AsUnion()); - bitset result = kNone; + int bitset = kNone; for (int i = 0; i < unioned->Length(); ++i) { - result |= unioned->Get(i)->BitsetLub(); + bitset |= unioned->Get(i)->BitsetLub(); } - return result; + return bitset; } else if (type->IsClass()) { // Little hack to avoid the need for a region for handlification here... return Config::is_class(type) ? Lub(*Config::as_class(type)) : @@ -82,18 +80,17 @@ TypeImpl::BitsetType::Lub(TypeImpl* type) { // The smallest bitset subsuming this type, ignoring explicit bounds. template -typename TypeImpl::bitset -TypeImpl::BitsetType::InherentLub(TypeImpl* type) { +int TypeImpl::BitsetType::InherentLub(TypeImpl* type) { DisallowHeapAllocation no_allocation; if (type->IsBitset()) { return type->AsBitset(); } else if (type->IsUnion()) { UnionHandle unioned = handle(type->AsUnion()); - bitset result = kNone; + int bitset = kNone; for (int i = 0; i < unioned->Length(); ++i) { - result |= unioned->Get(i)->InherentBitsetLub(); + bitset |= unioned->Get(i)->InherentBitsetLub(); } - return result; + return bitset; } else if (type->IsClass()) { return Lub(*type->AsClass()->Map()); } else if (type->IsConstant()) { @@ -114,8 +111,7 @@ TypeImpl::BitsetType::InherentLub(TypeImpl* type) { template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(i::Object* value) { +int TypeImpl::BitsetType::Lub(i::Object* value) { DisallowHeapAllocation no_allocation; if (value->IsNumber()) { return Lub(value->Number()) & (value->IsSmi() ? kTaggedInt : kTaggedPtr); @@ -125,8 +121,7 @@ TypeImpl::BitsetType::Lub(i::Object* value) { template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(double value) { +int TypeImpl::BitsetType::Lub(double value) { DisallowHeapAllocation no_allocation; if (i::IsMinusZero(value)) return kMinusZero; if (std::isnan(value)) return kNaN; @@ -137,21 +132,19 @@ TypeImpl::BitsetType::Lub(double value) { template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(double min, double max) { +int TypeImpl::BitsetType::Lub(double min, double max) { DisallowHeapAllocation no_allocation; DCHECK(dle(min, max)); if (deq(min, max)) return BitsetType::Lub(min); // Singleton range. - bitset result = BitsetType::kNumber ^ SEMANTIC(BitsetType::kNaN); - if (dle(0, min) || max < 0) result ^= SEMANTIC(BitsetType::kMinusZero); - return result; + int bitset = BitsetType::kNumber ^ SEMANTIC(BitsetType::kNaN); + if (dle(0, min) || max < 0) bitset ^= SEMANTIC(BitsetType::kMinusZero); + return bitset; // TODO(neis): Could refine this further by doing more checks on min/max. } template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(int32_t value) { +int TypeImpl::BitsetType::Lub(int32_t value) { if (value >= 0x40000000) { return i::SmiValuesAre31Bits() ? kOtherUnsigned31 : kUnsignedSmall; } @@ -162,8 +155,7 @@ TypeImpl::BitsetType::Lub(int32_t value) { template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(uint32_t value) { +int TypeImpl::BitsetType::Lub(uint32_t value) { DisallowHeapAllocation no_allocation; if (value >= 0x80000000u) return kOtherUnsigned32; if (value >= 0x40000000u) { @@ -174,8 +166,7 @@ TypeImpl::BitsetType::Lub(uint32_t value) { template -typename TypeImpl::bitset -TypeImpl::BitsetType::Lub(i::Map* map) { +int TypeImpl::BitsetType::Lub(i::Map* map) { DisallowHeapAllocation no_allocation; switch (map->instance_type()) { case STRING_TYPE: @@ -466,8 +457,8 @@ bool TypeImpl::UnionType::Wellformed() { template typename TypeImpl::TypeHandle TypeImpl::Rebound( - bitset bitset_bound, Region* region) { - TypeHandle bound = BitsetType::New(bitset_bound, region); + int bitset, Region* region) { + TypeHandle bound = BitsetType::New(bitset, region); if (this->IsClass()) { return ClassType::New(this->AsClass()->Map(), bound, region); } else if (this->IsConstant()) { @@ -495,16 +486,16 @@ typename TypeImpl::TypeHandle TypeImpl::Rebound( template -typename TypeImpl::bitset TypeImpl::BoundBy(TypeImpl* that) { +int TypeImpl::BoundBy(TypeImpl* that) { DCHECK(!this->IsUnion()); if (that->IsUnion()) { UnionType* unioned = that->AsUnion(); int length = unioned->Length(); - bitset result = BitsetType::kNone; + int bitset = BitsetType::kNone; for (int i = 0; i < length; ++i) { - result |= BoundBy(unioned->Get(i)->unhandle()); + bitset |= BoundBy(unioned->Get(i)->unhandle()); } - return result; + return bitset; } else if (that->IsClass() && this->IsClass() && *this->AsClass()->Map() == *that->AsClass()->Map()) { return that->BitsetLub(); @@ -524,7 +515,7 @@ typename TypeImpl::bitset TypeImpl::BoundBy(TypeImpl* that) { template int TypeImpl::IndexInUnion( - bitset bound, UnionHandle unioned, int current_size) { + int bound, UnionHandle unioned, int current_size) { DCHECK(!this->IsUnion()); for (int i = 0; i < current_size; ++i) { TypeHandle that = unioned->Get(i); @@ -554,7 +545,7 @@ int TypeImpl::ExtendUnion( UnionHandle result, int size, TypeHandle type, TypeHandle other, bool is_intersect, Region* region) { if (type->IsUnion()) { - UnionHandle unioned = Config::template cast(type); + UnionHandle unioned = handle(type->AsUnion()); for (int i = 0; i < unioned->Length(); ++i) { TypeHandle type_i = unioned->Get(i); DCHECK(i == 0 || !(type_i->IsBitset() || type_i->Is(unioned->Get(0)))); @@ -565,10 +556,10 @@ int TypeImpl::ExtendUnion( } else if (!type->IsBitset()) { DCHECK(type->IsClass() || type->IsConstant() || type->IsRange() || type->IsContext() || type->IsArray() || type->IsFunction()); - bitset inherent_bound = type->InherentBitsetLub(); - bitset old_bound = type->BitsetLub(); - bitset other_bound = type->BoundBy(other->unhandle()) & inherent_bound; - bitset new_bound = + int inherent_bound = type->InherentBitsetLub(); + int old_bound = type->BitsetLub(); + int other_bound = type->BoundBy(other->unhandle()) & inherent_bound; + int new_bound = is_intersect ? (old_bound & other_bound) : (old_bound | other_bound); if (new_bound != BitsetType::kNone) { int i = type->IndexInUnion(new_bound, result, size); @@ -577,7 +568,7 @@ int TypeImpl::ExtendUnion( } else if (result->Get(i)->IsBitset()) { return size; // Already fully subsumed. } else { - bitset type_i_bound = result->Get(i)->BitsetLub(); + int type_i_bound = result->Get(i)->BitsetLub(); new_bound |= type_i_bound; if (new_bound == type_i_bound) return size; } @@ -616,14 +607,14 @@ typename TypeImpl::TypeHandle TypeImpl::Union( if (!type2->IsBitset()) { size += (type2->IsUnion() ? type2->AsUnion()->Length() : 1); } - bitset bits = type1->BitsetGlb() | type2->BitsetGlb(); - if (bits != BitsetType::kNone) ++size; + int bitset = type1->BitsetGlb() | type2->BitsetGlb(); + if (bitset != BitsetType::kNone) ++size; DCHECK(size >= 1); UnionHandle unioned = UnionType::New(size, region); size = 0; - if (bits != BitsetType::kNone) { - unioned->Set(size++, BitsetType::New(bits, region)); + if (bitset != BitsetType::kNone) { + unioned->Set(size++, BitsetType::New(bitset, region)); } size = ExtendUnion(unioned, size, type1, type2, false, region); size = ExtendUnion(unioned, size, type2, type1, false, region); @@ -665,14 +656,14 @@ typename TypeImpl::TypeHandle TypeImpl::Intersect( if (!type2->IsBitset()) { size += (type2->IsUnion() ? type2->AsUnion()->Length() : 1); } - bitset bits = type1->BitsetGlb() & type2->BitsetGlb(); - if (bits != BitsetType::kNone) ++size; + int bitset = type1->BitsetGlb() & type2->BitsetGlb(); + if (bitset != BitsetType::kNone) ++size; DCHECK(size >= 1); UnionHandle unioned = UnionType::New(size, region); size = 0; - if (bits != BitsetType::kNone) { - unioned->Set(size++, BitsetType::New(bits, region)); + if (bitset != BitsetType::kNone) { + unioned->Set(size++, BitsetType::New(bitset, region)); } size = ExtendUnion(unioned, size, type1, type2, true, region); size = ExtendUnion(unioned, size, type2, type1, true, region); @@ -781,7 +772,7 @@ void TypeImpl::Iterator::Advance() { DisallowHeapAllocation no_allocation; ++index_; if (type_->IsUnion()) { - UnionHandle unioned = Config::template cast(type_); + UnionHandle unioned = handle(type_->AsUnion()); for (; index_ < unioned->Length(); ++index_) { if (matches(unioned->Get(index_))) return; } @@ -850,8 +841,8 @@ typename TypeImpl::TypeHandle TypeImpl::Convert( // Printing. template -const char* TypeImpl::BitsetType::Name(bitset bits) { - switch (bits) { +const char* TypeImpl::BitsetType::Name(int bitset) { + switch (bitset) { case REPRESENTATION(kAny): return "Any"; #define RETURN_NAMED_REPRESENTATION_TYPE(type, value) \ case REPRESENTATION(k##type): return #type; @@ -871,15 +862,15 @@ const char* TypeImpl::BitsetType::Name(bitset bits) { template void TypeImpl::BitsetType::Print(OStream& os, // NOLINT - bitset bits) { + int bitset) { DisallowHeapAllocation no_allocation; - const char* name = Name(bits); + const char* name = Name(bitset); if (name != NULL) { os << name; return; } - static const bitset named_bitsets[] = { + static const int named_bitsets[] = { #define BITSET_CONSTANT(type, value) REPRESENTATION(k##type), REPRESENTATION_BITSET_TYPE_LIST(BITSET_CONSTANT) #undef BITSET_CONSTANT @@ -891,16 +882,16 @@ void TypeImpl::BitsetType::Print(OStream& os, // NOLINT bool is_first = true; os << "("; - for (int i(arraysize(named_bitsets) - 1); bits != 0 && i >= 0; --i) { - bitset subset = named_bitsets[i]; - if ((bits & subset) == subset) { + for (int i(arraysize(named_bitsets) - 1); bitset != 0 && i >= 0; --i) { + int subset = named_bitsets[i]; + if ((bitset & subset) == subset) { if (!is_first) os << " | "; is_first = false; os << Name(subset); - bits -= subset; + bitset -= subset; } } - DCHECK(bits == 0); + DCHECK(bitset == 0); os << ")"; } diff --git a/src/types.h b/src/types.h index b5bfbcfdf7..2b77ad74ca 100644 --- a/src/types.h +++ b/src/types.h @@ -122,8 +122,8 @@ namespace internal { // IMPLEMENTATION // // Internally, all 'primitive' types, and their unions, are represented as -// bitsets. Bit 0 is reserved for tagging. Class is a heap pointer to the -// respective map. Only structured types require allocation. +// bitsets. Class is a heap pointer to the respective map. Only Constant's, or +// unions containing Class'es or Constant's, currently require allocation. // Note that the bitset representation is closed under both Union and Intersect. // // There are two type representations, using different allocation: @@ -139,23 +139,24 @@ namespace internal { // Values for bitset types #define MASK_BITSET_TYPE_LIST(V) \ - V(Representation, 0xff800000u) \ - V(Semantic, 0x007ffffeu) + V(Representation, static_cast(0xffc00000)) \ + V(Semantic, static_cast(0x003fffff)) #define REPRESENTATION(k) ((k) & BitsetType::kRepresentation) #define SEMANTIC(k) ((k) & BitsetType::kSemantic) #define REPRESENTATION_BITSET_TYPE_LIST(V) \ V(None, 0) \ - V(UntaggedInt1, 1 << 23 | kSemantic) \ - V(UntaggedInt8, 1 << 24 | kSemantic) \ - V(UntaggedInt16, 1 << 25 | kSemantic) \ - V(UntaggedInt32, 1 << 26 | kSemantic) \ - V(UntaggedFloat32, 1 << 27 | kSemantic) \ - V(UntaggedFloat64, 1 << 28 | kSemantic) \ - V(UntaggedPtr, 1 << 29 | kSemantic) \ - V(TaggedInt, 1 << 30 | kSemantic) \ - V(TaggedPtr, 1 << 31 | kSemantic) \ + V(UntaggedInt1, 1 << 22 | kSemantic) \ + V(UntaggedInt8, 1 << 23 | kSemantic) \ + V(UntaggedInt16, 1 << 24 | kSemantic) \ + V(UntaggedInt32, 1 << 25 | kSemantic) \ + V(UntaggedFloat32, 1 << 26 | kSemantic) \ + V(UntaggedFloat64, 1 << 27 | kSemantic) \ + V(UntaggedPtr, 1 << 28 | kSemantic) \ + V(TaggedInt, 1 << 29 | kSemantic) \ + /* MSB has to be sign-extended */ \ + V(TaggedPtr, static_cast(~0u << 30) | kSemantic) \ \ V(UntaggedInt, kUntaggedInt1 | kUntaggedInt8 | \ kUntaggedInt16 | kUntaggedInt32) \ @@ -165,28 +166,28 @@ namespace internal { V(Tagged, kTaggedInt | kTaggedPtr) #define SEMANTIC_BITSET_TYPE_LIST(V) \ - V(Null, 1 << 1 | REPRESENTATION(kTaggedPtr)) \ - V(Undefined, 1 << 2 | REPRESENTATION(kTaggedPtr)) \ - V(Boolean, 1 << 3 | REPRESENTATION(kTaggedPtr)) \ - V(UnsignedSmall, 1 << 4 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherSignedSmall, 1 << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherUnsigned31, 1 << 6 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherUnsigned32, 1 << 7 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherSigned32, 1 << 8 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(MinusZero, 1 << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(NaN, 1 << 10 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherNumber, 1 << 11 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(Symbol, 1 << 12 | REPRESENTATION(kTaggedPtr)) \ - V(InternalizedString, 1 << 13 | REPRESENTATION(kTaggedPtr)) \ - V(OtherString, 1 << 14 | REPRESENTATION(kTaggedPtr)) \ - V(Undetectable, 1 << 15 | REPRESENTATION(kTaggedPtr)) \ - V(Array, 1 << 16 | REPRESENTATION(kTaggedPtr)) \ - V(Buffer, 1 << 17 | REPRESENTATION(kTaggedPtr)) \ - V(Function, 1 << 18 | REPRESENTATION(kTaggedPtr)) \ - V(RegExp, 1 << 19 | REPRESENTATION(kTaggedPtr)) \ - V(OtherObject, 1 << 20 | REPRESENTATION(kTaggedPtr)) \ - V(Proxy, 1 << 21 | REPRESENTATION(kTaggedPtr)) \ - V(Internal, 1 << 22 | REPRESENTATION(kTagged | kUntagged)) \ + V(Null, 1 << 0 | REPRESENTATION(kTaggedPtr)) \ + V(Undefined, 1 << 1 | REPRESENTATION(kTaggedPtr)) \ + V(Boolean, 1 << 2 | REPRESENTATION(kTaggedPtr)) \ + V(UnsignedSmall, 1 << 3 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherSignedSmall, 1 << 4 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherUnsigned31, 1 << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherUnsigned32, 1 << 6 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherSigned32, 1 << 7 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(MinusZero, 1 << 8 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(NaN, 1 << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherNumber, 1 << 10 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(Symbol, 1 << 11 | REPRESENTATION(kTaggedPtr)) \ + V(InternalizedString, 1 << 12 | REPRESENTATION(kTaggedPtr)) \ + V(OtherString, 1 << 13 | REPRESENTATION(kTaggedPtr)) \ + V(Undetectable, 1 << 14 | REPRESENTATION(kTaggedPtr)) \ + V(Array, 1 << 15 | REPRESENTATION(kTaggedPtr)) \ + V(Buffer, 1 << 16 | REPRESENTATION(kTaggedPtr)) \ + V(Function, 1 << 17 | REPRESENTATION(kTaggedPtr)) \ + V(RegExp, 1 << 18 | REPRESENTATION(kTaggedPtr)) \ + V(OtherObject, 1 << 19 | REPRESENTATION(kTaggedPtr)) \ + V(Proxy, 1 << 20 | REPRESENTATION(kTaggedPtr)) \ + V(Internal, 1 << 21 | REPRESENTATION(kTagged | kUntagged)) \ \ V(SignedSmall, kUnsignedSmall | kOtherSignedSmall) \ V(Signed32, kSignedSmall | kOtherUnsigned31 | kOtherSigned32) \ @@ -206,7 +207,7 @@ namespace internal { V(Receiver, kObject | kProxy) \ V(NonNumber, kBoolean | kName | kNull | kReceiver | \ kUndefined | kInternal) \ - V(Any, 0xfffffffeu) + V(Any, -1) #define BITSET_TYPE_LIST(V) \ MASK_BITSET_TYPE_LIST(V) \ @@ -228,11 +229,11 @@ namespace internal { // static bool is_bitset(Type*); // static bool is_class(Type*); // static bool is_struct(Type*, int tag); -// static bitset as_bitset(Type*); +// static int as_bitset(Type*); // static i::Handle as_class(Type*); // static Handle::type as_struct(Type*); -// static Type* from_bitset(bitset); -// static Handle::type from_bitset(bitset, Region*); +// static Type* from_bitset(int bitset); +// static Handle::type from_bitset(int bitset, Region*); // static Handle::type from_class(i::Handle, Region*); // static Handle::type from_struct(Handle::type, int tag); // static Handle::type struct_create(int tag, int length, Region*); @@ -251,10 +252,9 @@ class TypeImpl : public Config::Base { public: // Auxiliary types. - typedef uintptr_t bitset; // Internal - class BitsetType; // Internal - class StructuralType; // Internal - class UnionType; // Internal + class BitsetType; // Internal + class StructuralType; // Internal + class UnionType; // Internal class ClassType; class ConstantType; @@ -457,7 +457,7 @@ class TypeImpl : public Config::Base { bool IsBitset() { return Config::is_bitset(this); } bool IsUnion() { return Config::is_struct(this, StructuralType::kUnionTag); } - bitset AsBitset() { + int AsBitset() { DCHECK(this->IsBitset()); return static_cast(this)->Bitset(); } @@ -465,15 +465,15 @@ class TypeImpl : public Config::Base { // Auxiliary functions. - bitset BitsetGlb() { return BitsetType::Glb(this); } - bitset BitsetLub() { return BitsetType::Lub(this); } - bitset InherentBitsetLub() { return BitsetType::InherentLub(this); } + int BitsetGlb() { return BitsetType::Glb(this); } + int BitsetLub() { return BitsetType::Lub(this); } + int InherentBitsetLub() { return BitsetType::InherentLub(this); } bool SlowIs(TypeImpl* that); - TypeHandle Rebound(bitset bound, Region* region); - bitset BoundBy(TypeImpl* that); - int IndexInUnion(bitset bound, UnionHandle unioned, int current_size); + TypeHandle Rebound(int bitset, Region* region); + int BoundBy(TypeImpl* that); + int IndexInUnion(int bound, UnionHandle unioned, int current_size); static int ExtendUnion( UnionHandle unioned, int current_size, TypeHandle t, TypeHandle other, bool is_intersect, Region* region); @@ -495,35 +495,35 @@ class TypeImpl::BitsetType : public TypeImpl { kUnusedEOL = 0 }; - bitset Bitset() { return Config::as_bitset(this); } + int Bitset() { return Config::as_bitset(this); } - static TypeImpl* New(bitset bits) { - return static_cast(Config::from_bitset(bits)); + static TypeImpl* New(int bitset) { + return static_cast(Config::from_bitset(bitset)); } - static TypeHandle New(bitset bits, Region* region) { - return Config::from_bitset(bits, region); + static TypeHandle New(int bitset, Region* region) { + return Config::from_bitset(bitset, region); } - static bool IsInhabited(bitset bits) { - return (bits & kRepresentation) && (bits & kSemantic); + static bool IsInhabited(int bitset) { + return (bitset & kRepresentation) && (bitset & kSemantic); } - static bool Is(bitset bits1, bitset bits2) { - return (bits1 | bits2) == bits2; + static bool Is(int bitset1, int bitset2) { + return (bitset1 | bitset2) == bitset2; } - static bitset Glb(TypeImpl* type); // greatest lower bound that's a bitset - static bitset Lub(TypeImpl* type); // least upper bound that's a bitset - static bitset Lub(i::Object* value); - static bitset Lub(double value); - static bitset Lub(int32_t value); - static bitset Lub(uint32_t value); - static bitset Lub(i::Map* map); - static bitset Lub(double min, double max); - static bitset InherentLub(TypeImpl* type); + static int Glb(TypeImpl* type); // greatest lower bound that's a bitset + static int Lub(TypeImpl* type); // least upper bound that's a bitset + static int Lub(i::Object* value); + static int Lub(double value); + static int Lub(int32_t value); + static int Lub(uint32_t value); + static int Lub(i::Map* map); + static int Lub(double min, double max); + static int InherentLub(TypeImpl* type); - static const char* Name(bitset); - static void Print(OStream& os, bitset); // NOLINT + static const char* Name(int bitset); + static void Print(OStream& os, int bitset); // NOLINT using TypeImpl::PrintTo; }; @@ -866,12 +866,12 @@ struct ZoneTypeConfig { static inline bool is_class(Type* type); static inline bool is_struct(Type* type, int tag); - static inline Type::bitset as_bitset(Type* type); + static inline int as_bitset(Type* type); static inline i::Handle as_class(Type* type); static inline Struct* as_struct(Type* type); - static inline Type* from_bitset(Type::bitset); - static inline Type* from_bitset(Type::bitset, Zone* zone); + static inline Type* from_bitset(int bitset); + static inline Type* from_bitset(int bitset, Zone* zone); static inline Type* from_class(i::Handle map, Zone* zone); static inline Type* from_struct(Struct* structured); @@ -913,12 +913,12 @@ struct HeapTypeConfig { static inline bool is_class(Type* type); static inline bool is_struct(Type* type, int tag); - static inline Type::bitset as_bitset(Type* type); + static inline int as_bitset(Type* type); static inline i::Handle as_class(Type* type); static inline i::Handle as_struct(Type* type); - static inline Type* from_bitset(Type::bitset); - static inline i::Handle from_bitset(Type::bitset, Isolate* isolate); + static inline Type* from_bitset(int bitset); + static inline i::Handle from_bitset(int bitset, Isolate* isolate); static inline i::Handle from_class( i::Handle map, Isolate* isolate); static inline i::Handle from_struct(i::Handle structure); diff --git a/test/cctest/test-types.cc b/test/cctest/test-types.cc index 487c826c17..422843f90e 100644 --- a/test/cctest/test-types.cc +++ b/test/cctest/test-types.cc @@ -12,22 +12,20 @@ using namespace v8::internal; // Testing auxiliaries (breaking the Type abstraction). -typedef uintptr_t bitset; - struct ZoneRep { typedef void* Struct; static bool IsStruct(Type* t, int tag) { return !IsBitset(t) && reinterpret_cast(AsStruct(t)[0]) == tag; } - static bool IsBitset(Type* t) { return reinterpret_cast(t) & 1; } + static bool IsBitset(Type* t) { return reinterpret_cast(t) & 1; } static bool IsUnion(Type* t) { return IsStruct(t, 6); } static Struct* AsStruct(Type* t) { return reinterpret_cast(t); } - static bitset AsBitset(Type* t) { - return reinterpret_cast(t) ^ 1u; + static int AsBitset(Type* t) { + return static_cast(reinterpret_cast(t) >> 1); } static Struct* AsUnion(Type* t) { return AsStruct(t); @@ -57,9 +55,7 @@ struct HeapRep { static bool IsUnion(Handle t) { return IsStruct(t, 6); } static Struct* AsStruct(Handle t) { return FixedArray::cast(*t); } - static bitset AsBitset(Handle t) { - return reinterpret_cast(*t); - } + static int AsBitset(Handle t) { return Smi::cast(*t)->value(); } static Struct* AsUnion(Handle t) { return AsStruct(t); } static int Length(Struct* structured) { return structured->length() - 1; } @@ -70,11 +66,9 @@ struct HeapRep { using HeapType::BitsetType::Glb; using HeapType::BitsetType::Lub; using HeapType::BitsetType::InherentLub; - static bitset Glb(Handle type) { return Glb(*type); } - static bitset Lub(Handle type) { return Lub(*type); } - static bitset InherentLub(Handle type) { - return InherentLub(*type); - } + static int Glb(Handle type) { return Glb(*type); } + static int Lub(Handle type) { return Lub(*type); } + static int InherentLub(Handle type) { return InherentLub(*type); } }; }; @@ -371,7 +365,7 @@ struct Tests : Rep { CHECK(type1->Is(type2)); CHECK(!type2->Is(type1)); if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) { - CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2)); + CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2)); } } @@ -379,7 +373,7 @@ struct Tests : Rep { CHECK(!type1->Is(type2)); CHECK(!type2->Is(type1)); if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) { - CHECK(Rep::AsBitset(type1) != Rep::AsBitset(type2)); + CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2)); } } @@ -387,8 +381,8 @@ struct Tests : Rep { CHECK(type1->Maybe(type2)); CHECK(type2->Maybe(type1)); if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) { - CHECK(0 != - (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask))); + CHECK_NE(0, + Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)); } } @@ -398,8 +392,8 @@ struct Tests : Rep { CHECK(!type1->Maybe(type2)); CHECK(!type2->Maybe(type1)); if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) { - CHECK(0 == - (Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask))); + CHECK_EQ(0, + Rep::AsBitset(type1) & Rep::AsBitset(type2) & Rep::AsBitset(mask)); } } @@ -408,8 +402,8 @@ struct Tests : Rep { CHECK(this->IsBitset(T.None)); CHECK(this->IsBitset(T.Any)); - CHECK(0 == this->AsBitset(T.None)); - CHECK(0xfffffffeu == this->AsBitset(T.Any)); + CHECK_EQ(0, this->AsBitset(T.None)); + CHECK_EQ(-1, this->AsBitset(T.Any)); // Union(T1, T2) is bitset for bitsets T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { @@ -451,8 +445,8 @@ struct Tests : Rep { TypeHandle type2 = *it2; TypeHandle union12 = T.Union(type1, type2); if (this->IsBitset(type1) && this->IsBitset(type2)) { - CHECK( - (this->AsBitset(type1) | this->AsBitset(type2)) == + CHECK_EQ( + this->AsBitset(type1) | this->AsBitset(type2), this->AsBitset(union12)); } } @@ -465,8 +459,8 @@ struct Tests : Rep { TypeHandle type2 = *it2; TypeHandle intersect12 = T.Intersect(type1, type2); if (this->IsBitset(type1) && this->IsBitset(type2)) { - CHECK( - (this->AsBitset(type1) & this->AsBitset(type2)) == + CHECK_EQ( + this->AsBitset(type1) & this->AsBitset(type2), this->AsBitset(intersect12)); } }