From e999cf2857e8f3ccbdf5ae2e90031d8b788fba2b Mon Sep 17 00:00:00 2001 From: "neis@chromium.org" Date: Wed, 23 Jul 2014 15:39:08 +0000 Subject: [PATCH] Revert "Minor clarifications and simplifications as well as additional checks." This reverts commit d32eacbdea3fc0c119da06abe95b07a83c67aa48. TBR=rossberg@chromium.org BUG= Review URL: https://codereview.chromium.org/410083005 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@22569 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/types.cc | 26 ++++++++++++++++---------- src/types.h | 26 +++++++++----------------- 2 files changed, 25 insertions(+), 27 deletions(-) diff --git a/src/types.cc b/src/types.cc index 8b68a7d..db638ed 100644 --- a/src/types.cc +++ b/src/types.cc @@ -262,7 +262,7 @@ bool TypeImpl::SlowIs(TypeImpl* that) { if (this->IsBitset() && SEMANTIC(this->AsBitset()) == BitsetType::kNone) { // Bitsets only have non-bitset supertypes along the representation axis. int that_bitset = that->BitsetGlb(); - return (BitsetType::Is(this->AsBitset(), that_bitset)); + return (this->AsBitset() | that_bitset) == that_bitset; } if (that->IsClass()) { @@ -313,12 +313,16 @@ bool TypeImpl::SlowIs(TypeImpl* that) { // T <= (T1 \/ ... \/ Tn) <=> (T <= T1) \/ ... \/ (T <= Tn) // (iff T is not a union) - ASSERT(!this->IsUnion() && that->IsUnion()); - UnionHandle unioned = handle(that->AsUnion()); - for (int i = 0; i < unioned->Length(); ++i) { - if (this->Is(unioned->Get(i))) return true; - if (this->IsBitset()) break; // Fast fail, only first field is a bitset. + ASSERT(!this->IsUnion()); + if (that->IsUnion()) { + UnionHandle unioned = handle(that->AsUnion()); + for (int i = 0; i < unioned->Length(); ++i) { + if (this->Is(unioned->Get(i))) return true; + if (this->IsBitset()) break; // Fast fail, only first field is a bitset. + } + return false; } + return false; } @@ -378,8 +382,11 @@ bool TypeImpl::Maybe(TypeImpl* that) { } ASSERT(!this->IsUnion() && !that->IsUnion()); - if (this->IsBitset() || that->IsBitset()) { - return BitsetType::IsInhabited(this->BitsetLub() & that->BitsetLub()); + if (this->IsBitset()) { + return BitsetType::IsInhabited(this->AsBitset() & that->BitsetLub()); + } + if (that->IsBitset()) { + return BitsetType::IsInhabited(this->BitsetLub() & that->AsBitset()); } if (this->IsClass()) { return that->IsClass() @@ -437,7 +444,6 @@ template typename TypeImpl::TypeHandle TypeImpl::Narrow( int bitset, Region* region) { TypeHandle bound = BitsetType::New(bitset, region); - ASSERT(!this->IsBitset() && this->Is(bound)); if (this->IsClass()) { return ClassType::New(this->AsClass()->Map(), bound, region); } else if (this->IsConstant()) { @@ -564,7 +570,7 @@ int TypeImpl::NormalizeUnion(UnionHandle result, int size, int bitset) { if (bitset != BitsetType::kNone && SEMANTIC(bitset) == BitsetType::kNone) { for (int i = 1; i < size; ++i) { int glb = result->Get(i)->BitsetGlb(); - if (BitsetType::Is(bitset, glb)) { + if ((bitset | glb) == glb) { for (int j = 1; j < size; ++j) { result->Set(j - 1, result->Get(j)); } diff --git a/src/types.h b/src/types.h index 7a6d545..d316fa1 100644 --- a/src/types.h +++ b/src/types.h @@ -68,12 +68,11 @@ namespace internal { // None <= R // R <= Any // -// UntaggedInt = UntaggedInt1 \/ UntaggedInt8 \/ -// UntaggedInt16 \/ UntaggedInt32 -// UntaggedFloat = UntaggedFloat32 \/ UntaggedFloat64 -// UntaggedNumber = UntaggedInt \/ UntaggedFloat -// Untagged = UntaggedNumber \/ UntaggedPtr -// Tagged = TaggedInt \/ TaggedPtr +// UntaggedInt <= UntaggedInt8 \/ UntaggedInt16 \/ UntaggedInt32) +// UntaggedFloat <= UntaggedFloat32 \/ UntaggedFloat64 +// UntaggedNumber <= UntaggedInt \/ UntaggedFloat +// Untagged <= UntaggedNumber \/ UntaggedPtr +// Tagged <= TaggedInt \/ TaggedPtr // // Subtyping relates the two dimensions, for example: // @@ -503,10 +502,6 @@ class TypeImpl::BitsetType : public TypeImpl { return (bitset & kRepresentation) && (bitset & kSemantic); } - static bool Is(int bitset1, int bitset2) { - return (bitset1 | bitset2) == bitset2; - } - 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); @@ -617,7 +612,6 @@ class TypeImpl::ClassType : public StructuralType { static ClassHandle New( i::Handle map, TypeHandle bound, Region* region) { - ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*map))); ClassHandle type = Config::template cast( StructuralType::New(StructuralType::kClassTag, 2, region)); type->Set(0, bound); @@ -654,7 +648,6 @@ class TypeImpl::ConstantType : public StructuralType { static ConstantHandle New( i::Handle value, TypeHandle bound, Region* region) { - ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::Lub(*value))); ConstantHandle type = Config::template cast( StructuralType::New(StructuralType::kConstantTag, 2, region)); type->Set(0, bound); @@ -686,7 +679,8 @@ class TypeImpl::RangeType : public StructuralType { static RangeHandle New( double min, double max, TypeHandle bound, Region* region) { - ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kNumber)); + ASSERT(SEMANTIC(bound->AsBitset() | BitsetType::kNumber) + == SEMANTIC(BitsetType::kNumber)); ASSERT(!std::isnan(min) && !std::isnan(max) && min <= max); RangeHandle type = Config::template cast( StructuralType::New(StructuralType::kRangeTag, 3, region)); @@ -721,8 +715,6 @@ class TypeImpl::ContextType : public StructuralType { TypeHandle Outer() { return this->Get(1); } static ContextHandle New(TypeHandle outer, TypeHandle bound, Region* region) { - ASSERT(BitsetType::Is( - bound->AsBitset(), BitsetType::kInternal & BitsetType::kTaggedPtr)); ContextHandle type = Config::template cast( StructuralType::New(StructuralType::kContextTag, 2, region)); type->Set(0, bound); @@ -753,7 +745,7 @@ class TypeImpl::ArrayType : public StructuralType { TypeHandle Element() { return this->Get(1); } static ArrayHandle New(TypeHandle element, TypeHandle bound, Region* region) { - ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kArray)); + ASSERT(SEMANTIC(bound->AsBitset()) == SEMANTIC(BitsetType::kArray)); ArrayHandle type = Config::template cast( StructuralType::New(StructuralType::kArrayTag, 2, region)); type->Set(0, bound); @@ -790,7 +782,7 @@ class TypeImpl::FunctionType : public StructuralType { static FunctionHandle New( TypeHandle result, TypeHandle receiver, TypeHandle bound, int arity, Region* region) { - ASSERT(BitsetType::Is(bound->AsBitset(), BitsetType::kFunction)); + ASSERT(SEMANTIC(bound->AsBitset()) == SEMANTIC(BitsetType::kFunction)); FunctionHandle type = Config::template cast( StructuralType::New(StructuralType::kFunctionTag, 3 + arity, region)); type->Set(0, bound); -- 2.7.4