Avoid number range holes in bitset types.

src/types.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_TYPES_H_
 #define V8_TYPES_H_
 
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/handles.h"
@@ skipping 142 matching lines @@
 // -----------------------------------------------------------------------------
 // Values for bitset types
 
 #define MASK_BITSET_TYPE_LIST(V) \
   V(Representation, 0xff800000u) \
   V(Semantic,       0x007ffffeu)
 
 #define REPRESENTATION(k) ((k) & BitsetType::kRepresentation)
 #define SEMANTIC(k)       ((k) & BitsetType::kSemantic)
 
-#define REPRESENTATION_BITSET_TYPE_LIST(V) \
-  V(None,             0)                   \
+#define REPRESENTATION_BITSET_TYPE_LIST(V)  \
+  V(None,             0)                    \
   V(UntaggedInt1,     1u << 23 | kSemantic) \
   V(UntaggedInt8,     1u << 24 | kSemantic) \
   V(UntaggedInt16,    1u << 25 | kSemantic) \
   V(UntaggedInt32,    1u << 26 | kSemantic) \
   V(UntaggedFloat32,  1u << 27 | kSemantic) \
   V(UntaggedFloat64,  1u << 28 | kSemantic) \
   V(UntaggedPtr,      1u << 29 | kSemantic) \
   V(TaggedInt,        1u << 30 | kSemantic) \
   V(TaggedPtr,        1u << 31 | kSemantic) \
   \
   V(UntaggedInt,      kUntaggedInt1 | kUntaggedInt8 |      \
                       kUntaggedInt16 | kUntaggedInt32)     \
   V(UntaggedFloat,    kUntaggedFloat32 | kUntaggedFloat64) \
   V(UntaggedNumber,   kUntaggedInt | kUntaggedFloat)       \
   V(Untagged,         kUntaggedNumber | kUntaggedPtr)      \
   V(Tagged,           kTaggedInt | kTaggedPtr)
 
-#define SEMANTIC_BITSET_TYPE_LIST(V) \
-  V(Null,                1u << 1  | REPRESENTATION(kTaggedPtr)) \
-  V(Undefined,           1u << 2  | REPRESENTATION(kTaggedPtr)) \
-  V(Boolean,             1u << 3  | REPRESENTATION(kTaggedPtr)) \
-  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(Symbol,              1u << 12 | REPRESENTATION(kTaggedPtr)) \
-  V(InternalizedString,  1u << 13 | REPRESENTATION(kTaggedPtr)) \
-  V(OtherString,         1u << 14 | REPRESENTATION(kTaggedPtr)) \
-  V(Undetectable,        1u << 15 | REPRESENTATION(kTaggedPtr)) \
-  V(Array,               1u << 16 | REPRESENTATION(kTaggedPtr)) \
-  V(Buffer,              1u << 17 | REPRESENTATION(kTaggedPtr)) \
-  V(Function,            1u << 18 | REPRESENTATION(kTaggedPtr)) \
-  V(RegExp,              1u << 19 | REPRESENTATION(kTaggedPtr)) \
-  V(OtherObject,         1u << 20 | REPRESENTATION(kTaggedPtr)) \
-  V(Proxy,               1u << 21 | REPRESENTATION(kTaggedPtr)) \
-  V(Internal,            1u << 22 | REPRESENTATION(kTagged | kUntagged)) \
-  \
-  V(SignedSmall,         kUnsignedSmall | kOtherSignedSmall) \
-  V(Signed32,            kSignedSmall | kOtherUnsigned31 | kOtherSigned32) \
-  V(Unsigned32,          kUnsignedSmall | kOtherUnsigned31 | kOtherUnsigned32) \
-  V(Integral32,          kSigned32 | kUnsigned32) \
-  V(OrderedNumber,       kIntegral32 | kMinusZero | kOtherNumber) \
-  V(Number,              kOrderedNumber | kNaN) \
-  V(String,              kInternalizedString | kOtherString) \
-  V(UniqueName,          kSymbol | kInternalizedString) \
-  V(Name,                kSymbol | kString) \
-  V(NumberOrString,      kNumber | kString) \
-  V(PlainPrimitive,      kNumberOrString | kBoolean | kNull | kUndefined) \
-  V(Primitive,           kSymbol | kPlainPrimitive) \
-  V(DetectableObject,    kArray | kFunction | kRegExp | kOtherObject) \
-  V(DetectableReceiver,  kDetectableObject | kProxy) \
-  V(Detectable,          kDetectableReceiver | kNumber | kName) \
-  V(Object,              kDetectableObject | kUndetectable) \
-  V(Receiver,            kObject | kProxy) \
-  V(Unique,              kBoolean | kUniqueName | kNull | kUndefined | \
-                         kReceiver) \
-  V(NonNumber,           kUnique | kString | kInternal) \
-  V(Any,                 0xfffffffeu)
+#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(NegativeSignedSmall, 1u << 5 | REPRESENTATION(kTagged | kUntaggedNumber))  \
+  V(Null,                1u << 6 | REPRESENTATION(kTaggedPtr))                 \
+  V(Undefined,           1u << 7 | REPRESENTATION(kTaggedPtr))                 \
+  V(Boolean,             1u << 8 | REPRESENTATION(kTaggedPtr))                 \
+  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(kTaggedPtr))                \
+  V(InternalizedString,  1u << 13 | REPRESENTATION(kTaggedPtr))                \
+  V(OtherString,         1u << 14 | REPRESENTATION(kTaggedPtr))                \
+  V(Undetectable,        1u << 15 | REPRESENTATION(kTaggedPtr))                \
+  V(Array,               1u << 16 | REPRESENTATION(kTaggedPtr))                \
+  V(Buffer,              1u << 17 | REPRESENTATION(kTaggedPtr))                \
+  V(Function,            1u << 18 | REPRESENTATION(kTaggedPtr))                \
+  V(RegExp,              1u << 19 | REPRESENTATION(kTaggedPtr))                \
+  V(OtherObject,         1u << 20 | REPRESENTATION(kTaggedPtr))                \
+  V(Proxy,               1u << 21 | REPRESENTATION(kTaggedPtr))                \
+  V(Internal,            1u << 22 | REPRESENTATION(kTagged | kUntagged))       \
+                                                                               \
+  V(SignedSmall,         kUnsignedSmall | kNegativeSignedSmall)                \
+  V(Signed32,            kSignedSmall | kOtherUnsigned31 | kOtherSigned32)     \
+  V(NegativeSigned32,    kNegativeSignedSmall | kOtherSigned32)                \
+  V(NonNegativeSigned32, kUnsignedSmall | kOtherUnsigned31)                    \
+  V(Unsigned32,          kNonNegativeSigned32 | kOtherUnsigned32)              \
+  V(Integral32,          kSigned32 | kUnsigned32)                              \
+  V(PlainNumber,         kIntegral32 | kOtherNumber)                           \
+  V(OrderedNumber,       kPlainNumber | kMinusZero)                            \
+  V(Number,              kOrderedNumber | kNaN)                                \
+  V(String,              kInternalizedString | kOtherString)                   \
+  V(UniqueName,          kSymbol | kInternalizedString)                        \
+  V(Name,                kSymbol | kString)                                    \
+  V(NumberOrString,      kNumber | kString)                                    \
+  V(PlainPrimitive,      kNumberOrString | kBoolean | kNull | kUndefined)      \
+  V(Primitive,           kSymbol | kPlainPrimitive)                            \
+  V(DetectableObject,    kArray | kFunction | kRegExp | kOtherObject)          \
+  V(DetectableReceiver,  kDetectableObject | kProxy)                           \
+  V(Detectable,          kDetectableReceiver | kNumber | kName)                \
+  V(Object,              kDetectableObject | kUndetectable)                    \
+  V(Receiver,            kObject | kProxy)                                     \
+  V(Unique,              kBoolean | kUniqueName | kNull | kUndefined |         \
+                         kReceiver)                                            \
+  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.
  *
  * 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) \
   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)
 
 
 // -----------------------------------------------------------------------------
 // The abstract Type class, parameterized over the low-level representation.
 
 // struct Config {
 //   typedef TypeImpl<Config> Type;
 //   typedef Base;
 //   typedef Struct;
 //   typedef Region;
@@ skipping 316 matching lines @@
     #define DECLARE_TYPE(type, value) k##type = (value),
     BITSET_TYPE_LIST(DECLARE_TYPE)
     #undef DECLARE_TYPE
     kUnusedEOL = 0
   };
 
   bitset Bitset() { return Config::as_bitset(this); }
 
   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) {
     DCHECK(bits == kNone || IsInhabited(bits));
     return Config::from_bitset(bits, region);
   }
   // TODO(neis): Eventually allow again for types with empty semantics
   // part and modify intersection and possibly subtyping accordingly.
 
   static bool IsInhabited(bitset bits) {
@@ skipping 459 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_