From: jarin Date: Thu, 11 Dec 2014 17:50:02 +0000 (-0800) Subject: Reland of "Avoid number range holes in bitset types." X-Git-Tag: upstream/4.7.83~5254 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=5913c7cc3ffec026e67129a2a3a73ea226ff0433;p=platform%2Fupstream%2Fv8.git Reland of "Avoid number range holes in bitset types." This reverts commit 8a6cbf0a8632f39bc5bf740db672aa543e3e0f88. R=rossberg@chromium.org BUG= Review URL: https://codereview.chromium.org/788313002 Cr-Commit-Position: refs/heads/master@{#25786} --- diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc index 5377502..31de440 100644 --- a/src/compiler/typer.cc +++ b/src/compiler/typer.cc @@ -175,10 +175,6 @@ Typer::Typer(Graph* graph, MaybeHandle context) boolean_or_number = Type::Union(Type::Boolean(), Type::Number(), zone); undefined_or_null = Type::Union(Type::Undefined(), Type::Null(), zone); undefined_or_number = Type::Union(Type::Undefined(), Type::Number(), zone); - negative_signed32 = Type::Union( - Type::SignedSmall(), Type::OtherSigned32(), zone); - non_negative_signed32 = Type::Union( - Type::UnsignedSmall(), Type::OtherUnsigned31(), zone); singleton_false = Type::Constant(f->false_value(), zone); singleton_true = Type::Constant(f->true_value(), zone); singleton_zero = Type::Range(zero, zero, zone); @@ -197,8 +193,7 @@ Typer::Typer(Graph* graph, MaybeHandle context) number_fun2_ = Type::Function(number, number, number, zone); weakint_fun1_ = Type::Function(weakint, number, zone); - random_fun_ = Type::Function(Type::Union( - Type::UnsignedSmall(), Type::OtherNumber(), zone), zone); + random_fun_ = Type::Function(Type::OrderedNumber(), zone); const int limits_count = 20; @@ -875,11 +870,12 @@ Type* Typer::Visitor::JSBitwiseXorTyper(Type* lhs, Type* rhs, Typer* t) { 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 t->non_negative_signed32; + 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. - return t->negative_signed32; + // TODO(jarin) Use a range here. + return Type::NegativeSigned32(); } return Type::Signed32(); } diff --git a/src/types.cc b/src/types.cc index a73df2b..c4f1bae 100644 --- a/src/types.cc +++ b/src/types.cc @@ -279,35 +279,33 @@ TypeImpl::BitsetType::Lub(double value) { if (i::IsMinusZero(value)) return kMinusZero; if (std::isnan(value)) return kNaN; if (IsUint32Double(value) || IsInt32Double(value)) return Lub(value, value); - return kOtherNumber; + return kPlainNumber; } // Minimum values of regular numeric bitsets when SmiValuesAre31Bits. -template +template const typename TypeImpl::BitsetType::BitsetMin -TypeImpl::BitsetType::BitsetMins31[] = { - {kOtherNumber, -V8_INFINITY}, - {kOtherSigned32, kMinInt}, - {kOtherSignedSmall, -0x40000000}, - {kUnsignedSmall, 0}, - {kOtherUnsigned31, 0x40000000}, - {kOtherUnsigned32, 0x80000000}, - {kOtherNumber, static_cast(kMaxUInt32) + 1} -}; + TypeImpl::BitsetType::BitsetMins31[] = { + {kOtherNumber, -V8_INFINITY}, + {kOtherSigned32, kMinInt}, + {kNegativeSignedSmall, -0x40000000}, + {kUnsignedSmall, 0}, + {kOtherUnsigned31, 0x40000000}, + {kOtherUnsigned32, 0x80000000}, + {kOtherNumber, static_cast(kMaxUInt32) + 1}}; // Minimum values of regular numeric bitsets when SmiValuesAre32Bits. // OtherSigned32 and OtherUnsigned31 are empty (see the diagrams in types.h). -template +template const typename TypeImpl::BitsetType::BitsetMin -TypeImpl::BitsetType::BitsetMins32[] = { - {kOtherNumber, -V8_INFINITY}, - {kOtherSignedSmall, kMinInt}, - {kUnsignedSmall, 0}, - {kOtherUnsigned32, 0x80000000}, - {kOtherNumber, static_cast(kMaxUInt32) + 1} -}; + TypeImpl::BitsetType::BitsetMins32[] = { + {kOtherNumber, -V8_INFINITY}, + {kNegativeSignedSmall, kMinInt}, + {kUnsignedSmall, 0}, + {kOtherUnsigned32, 0x80000000}, + {kOtherNumber, static_cast(kMaxUInt32) + 1}}; template @@ -317,6 +315,11 @@ TypeImpl::BitsetType::Lub(double min, double max) { int lub = kNone; 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 < BitsetMinsSize(); ++i) { if (min < mins[i].min) { lub |= mins[i-1].bits; @@ -987,6 +990,7 @@ void TypeImpl::BitsetType::Print(std::ostream& os, // NOLINT #undef BITSET_CONSTANT #define BITSET_CONSTANT(type, value) SEMANTIC(k##type), + INTERNAL_BITSET_TYPE_LIST(BITSET_CONSTANT) SEMANTIC_BITSET_TYPE_LIST(BITSET_CONSTANT) #undef BITSET_CONSTANT }; diff --git a/src/types.h b/src/types.h index 969a81d..e9fc5d6 100644 --- a/src/types.h +++ b/src/types.h @@ -188,18 +188,20 @@ namespace internal { V(Untagged, kUntaggedNumber | kUntaggedPointer) \ V(Tagged, kTaggedSigned | kTaggedPointer) +#define INTERNAL_BITSET_TYPE_LIST(V) \ + V(OtherUnsigned31, 1u << 1 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherUnsigned32, 1u << 2 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherSigned32, 1u << 3 | REPRESENTATION(kTagged | kUntaggedNumber)) \ + V(OtherNumber, 1u << 4 | REPRESENTATION(kTagged | kUntaggedNumber)) + #define SEMANTIC_BITSET_TYPE_LIST(V) \ - V(Null, 1u << 1 | REPRESENTATION(kTaggedPointer)) \ - V(Undefined, 1u << 2 | REPRESENTATION(kTaggedPointer)) \ - V(Boolean, 1u << 3 | REPRESENTATION(kTaggedPointer)) \ - V(UnsignedSmall, 1u << 4 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherSignedSmall, 1u << 5 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherUnsigned31, 1u << 6 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherUnsigned32, 1u << 7 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherSigned32, 1u << 8 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(MinusZero, 1u << 9 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(NaN, 1u << 10 | REPRESENTATION(kTagged | kUntaggedNumber)) \ - V(OtherNumber, 1u << 11 | 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(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(InternalizedString, 1u << 13 | REPRESENTATION(kTaggedPointer)) \ V(OtherString, 1u << 14 | REPRESENTATION(kTaggedPointer)) \ @@ -209,11 +211,14 @@ namespace internal { V(Proxy, 1u << 18 | REPRESENTATION(kTaggedPointer)) \ V(Internal, 1u << 19 | REPRESENTATION(kTagged | kUntagged)) \ \ - V(SignedSmall, kUnsignedSmall | kOtherSignedSmall) \ + 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(OrderedNumber, kIntegral32 | kMinusZero | kOtherNumber) \ + V(PlainNumber, kIntegral32 | kOtherNumber) \ + V(OrderedNumber, kPlainNumber | kMinusZero) \ V(Number, kOrderedNumber | kNaN) \ V(String, kInternalizedString | kOtherString) \ V(UniqueName, kSymbol | kInternalizedString) \ @@ -231,6 +236,7 @@ namespace internal { V(NonNumber, kUnique | kString | kInternal) \ V(Any, 0xfffffffeu) + /* * The following diagrams show how integers (in the mathematical sense) are * divided among the different atomic numerical types. @@ -259,9 +265,11 @@ namespace internal { REPRESENTATION_BITSET_TYPE_LIST(V) \ SEMANTIC_BITSET_TYPE_LIST(V) -#define BITSET_TYPE_LIST(V) \ - MASK_BITSET_TYPE_LIST(V) \ - PROPER_BITSET_TYPE_LIST(V) +#define BITSET_TYPE_LIST(V) \ + MASK_BITSET_TYPE_LIST(V) \ + REPRESENTATION_BITSET_TYPE_LIST(V) \ + INTERNAL_BITSET_TYPE_LIST(V) \ + SEMANTIC_BITSET_TYPE_LIST(V) // ----------------------------------------------------------------------------- @@ -598,6 +606,20 @@ class TypeImpl::BitsetType : public TypeImpl { static TypeImpl* New(bitset 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) { diff --git a/test/cctest/compiler/test-js-typed-lowering.cc b/test/cctest/compiler/test-js-typed-lowering.cc index a132a13..667ed61 100644 --- a/test/cctest/compiler/test-js-typed-lowering.cc +++ b/test/cctest/compiler/test-js-typed-lowering.cc @@ -167,17 +167,19 @@ static Type* kStringTypes[] = {Type::InternalizedString(), Type::OtherString(), static Type* kInt32Types[] = { - Type::UnsignedSmall(), Type::OtherSignedSmall(), Type::OtherUnsigned31(), - Type::OtherUnsigned32(), Type::OtherSigned32(), Type::SignedSmall(), - Type::Signed32(), Type::Unsigned32(), Type::Integral32()}; + Type::UnsignedSmall(), Type::NegativeSigned32(), + Type::NonNegativeSigned32(), Type::SignedSmall(), + Type::Signed32(), Type::Unsigned32(), + Type::Integral32()}; static Type* kNumberTypes[] = { - Type::UnsignedSmall(), Type::OtherSignedSmall(), Type::OtherUnsigned31(), - Type::OtherUnsigned32(), Type::OtherSigned32(), Type::SignedSmall(), - Type::Signed32(), Type::Unsigned32(), Type::Integral32(), - Type::MinusZero(), Type::NaN(), Type::OtherNumber(), - Type::OrderedNumber(), 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(), @@ -304,12 +306,13 @@ class JSBitwiseShiftTypedLoweringTester : public JSTypedLoweringTester { TEST(Int32BitwiseShifts) { JSBitwiseShiftTypedLoweringTester R; - Type* types[] = { - Type::SignedSmall(), Type::UnsignedSmall(), Type::OtherSigned32(), - Type::Unsigned32(), Type::Signed32(), Type::MinusZero(), - Type::NaN(), Type::OtherNumber(), Type::Undefined(), - Type::Null(), Type::Boolean(), Type::Number(), - 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); @@ -369,10 +372,11 @@ TEST(Int32BitwiseBinops) { JSBitwiseTypedLoweringTester R; Type* types[] = { - Type::SignedSmall(), Type::UnsignedSmall(), Type::Unsigned32(), - Type::Signed32(), Type::MinusZero(), Type::NaN(), - Type::OtherNumber(), Type::Undefined(), Type::Null(), - Type::Boolean(), Type::Number(), Type::String()}; + Type::SignedSmall(), Type::UnsignedSmall(), Type::Unsigned32(), + Type::Signed32(), Type::MinusZero(), Type::NaN(), + Type::OrderedNumber(), Type::PlainNumber(), Type::Undefined(), + Type::Null(), Type::Boolean(), Type::Number(), + Type::String()}; for (size_t i = 0; i < arraysize(types); ++i) { Node* p0 = R.Parameter(types[i], 0); diff --git a/test/cctest/test-types.cc b/test/cctest/test-types.cc index 6193dd6..ebef527 100644 --- a/test/cctest/test-types.cc +++ b/test/cctest/test-types.cc @@ -294,39 +294,55 @@ struct Tests : Rep { 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.OtherSignedSmall)); - CHECK(T.Constant(fac->NewNumber(-0x3fffffff))->Is(T.OtherSignedSmall)); - CHECK(T.Constant(fac->NewNumber(-0x40000000))->Is(T.OtherSignedSmall)); + 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.OtherUnsigned31)); - CHECK(T.Constant(fac->NewNumber(0x7fffffff))->Is(T.OtherUnsigned31)); - CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.OtherSigned32)); - CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.OtherSigned32)); - CHECK(T.Constant(fac->NewNumber(-0x7fffffff-1))->Is(T.OtherSigned32)); + 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.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(0x40000000))->Is(T.OtherUnsigned31)); - CHECK(!T.Constant(fac->NewNumber(0x7fffffff))->Is(T.OtherUnsigned31)); - CHECK(T.Constant(fac->NewNumber(-0x40000001))->Is(T.OtherSignedSmall)); - CHECK(T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.OtherSignedSmall)); - CHECK(T.Constant(fac->NewNumber(-0x7fffffff-1))->Is(T.OtherSignedSmall)); - CHECK(!T.Constant(fac->NewNumber(-0x40000001))->Is(T.OtherSigned32)); - CHECK(!T.Constant(fac->NewNumber(-0x7fffffff))->Is(T.OtherSigned32)); - CHECK(!T.Constant(fac->NewNumber(-0x7fffffff-1))->Is(T.OtherSigned32)); - } - CHECK(T.Constant(fac->NewNumber(0x80000000u))->Is(T.OtherUnsigned32)); - CHECK(T.Constant(fac->NewNumber(0xffffffffu))->Is(T.OtherUnsigned32)); - CHECK(T.Constant(fac->NewNumber(0xffffffffu+1.0))->Is(T.OtherNumber)); - CHECK(T.Constant(fac->NewNumber(-0x7fffffff-2.0))->Is(T.OtherNumber)); - CHECK(T.Constant(fac->NewNumber(0.1))->Is(T.OtherNumber)); - CHECK(T.Constant(fac->NewNumber(-10.1))->Is(T.OtherNumber)); - CHECK(T.Constant(fac->NewNumber(10e60))->Is(T.OtherNumber)); + 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.NonNegativeSigned32)); + CHECK(T.Constant(fac->NewNumber(0xffffffffu))->Is(T.Unsigned32)); + 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)); + CHECK(!T.Constant(fac->NewNumber(-0x7fffffff - 2.0))->Is(T.Integral32)); + CHECK(T.Constant(fac->NewNumber(0.1))->Is(T.PlainNumber)); + CHECK(!T.Constant(fac->NewNumber(0.1))->Is(T.Integral32)); + CHECK(T.Constant(fac->NewNumber(-10.1))->Is(T.PlainNumber)); + CHECK(!T.Constant(fac->NewNumber(-10.1))->Is(T.Integral32)); + CHECK(T.Constant(fac->NewNumber(10e60))->Is(T.PlainNumber)); + CHECK(!T.Constant(fac->NewNumber(10e60))->Is(T.Integral32)); CHECK(T.Constant(fac->NewNumber(-1.0*0.0))->Is(T.MinusZero)); CHECK(T.Constant(fac->NewNumber(v8::base::OS::nan_value()))->Is(T.NaN)); - CHECK(T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.OtherNumber)); - CHECK(T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.OtherNumber)); + CHECK(T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.PlainNumber)); + CHECK(!T.Constant(fac->NewNumber(V8_INFINITY))->Is(T.Integral32)); + CHECK(T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.PlainNumber)); + CHECK(!T.Constant(fac->NewNumber(-V8_INFINITY))->Is(T.Integral32)); } void Range() { @@ -904,7 +920,7 @@ struct Tests : Rep { if (type->IsRange()) { TypeHandle lub = Rep::BitsetType::New( Rep::BitsetType::Lub(type), T.region()); - CHECK(lub->Is(T.Union(T.Integral32, T.OtherNumber))); + CHECK(lub->Is(T.PlainNumber)); } } diff --git a/test/cctest/types-fuzz.h b/test/cctest/types-fuzz.h index 233249a..4eac64c 100644 --- a/test/cctest/types-fuzz.h +++ b/test/cctest/types-fuzz.h @@ -40,13 +40,8 @@ class Types { Types(Region* region, Isolate* isolate) : region_(region), rng_(isolate->random_number_generator()) { #define DECLARE_TYPE(name, value) \ - name = Type::name(region); \ - if (SmiValuesAre31Bits() || \ - (!Type::name(region)->Equals(Type::OtherSigned32()) && \ - !Type::name(region)->Equals(Type::OtherUnsigned31()))) { \ - /* Hack: Avoid generating those empty bitset types. */ \ - types.push_back(name); \ - } + name = Type::name(region); \ + types.push_back(name); PROPER_BITSET_TYPE_LIST(DECLARE_TYPE) #undef DECLARE_TYPE @@ -133,7 +128,7 @@ class Types { Handle uninitialized; #define DECLARE_TYPE(name, value) TypeHandle name; - BITSET_TYPE_LIST(DECLARE_TYPE) + PROPER_BITSET_TYPE_LIST(DECLARE_TYPE) #undef DECLARE_TYPE TypeHandle ObjectClass; @@ -238,12 +233,6 @@ class Types { int j = rng_->NextInt(n); #define PICK_BITSET_TYPE(type, value) \ if (j-- == 0) { \ - if (!SmiValuesAre31Bits() && \ - (Type::type(region_)->Equals(Type::OtherSigned32()) || \ - Type::type(region_)->Equals(Type::OtherUnsigned31()))) { \ - /* Hack: Avoid generating those empty bitset types. */ \ - continue; \ - } \ TypeHandle tmp = Type::Intersect( \ result, Type::type(region_), region_); \ if (tmp->Is(Type::None()) && i != 0) { \ diff --git a/test/unittests/compiler/js-builtin-reducer-unittest.cc b/test/unittests/compiler/js-builtin-reducer-unittest.cc index 48ad1b7..0747f0c 100644 --- a/test/unittests/compiler/js-builtin-reducer-unittest.cc +++ b/test/unittests/compiler/js-builtin-reducer-unittest.cc @@ -58,11 +58,12 @@ namespace { // TODO(mstarzinger): Find a common place and unify with test-js-typed-lowering. Type* const kNumberTypes[] = { - Type::UnsignedSmall(), Type::OtherSignedSmall(), Type::OtherUnsigned31(), - Type::OtherUnsigned32(), Type::OtherSigned32(), Type::SignedSmall(), - Type::Signed32(), Type::Unsigned32(), Type::Integral32(), - Type::MinusZero(), Type::NaN(), Type::OtherNumber(), - Type::OrderedNumber(), 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