Use distinct maps for oddballs with special handling in the type system.

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 "handles.h"
 
 namespace v8 {
 namespace internal {
 
 // A simple type system for compiler-internal use. It is based entirely on
 // union types, and all subtyping hence amounts to set inclusion. Besides the
 // obvious primitive types and some predefined unions, the type language also
 // can express class types (a.k.a. specific maps) and singleton types (i.e.,
 // concrete constants).
 //
 // Types consist of two dimensions: semantic (value range) and representation.
 // Both are related through subtyping.
 //
 // The following equations and inequations hold for the semantic axis:
 //
 //   None <= T
 //   T <= Any
 //
-//   Oddball = Boolean \/ Null \/ Undefined
 //   Number = Signed32 \/ Unsigned32 \/ Double
 //   Smi <= Signed32
 //   Name = String \/ Symbol
 //   UniqueName = InternalizedString \/ Symbol
 //   InternalizedString < String
 //
 //   Receiver = Object \/ Proxy
 //   Array < Object
 //   Function < Object
 //   RegExp < Object
@@ skipping 97 matching lines @@
   V(InternalizedString,  1 << 8  | REPRESENTATION(kTaggedPtr)) \
   V(OtherString,         1 << 9  | REPRESENTATION(kTaggedPtr)) \
   V(Undetectable,        1 << 10 | REPRESENTATION(kTaggedPtr)) \
   V(Array,               1 << 11 | REPRESENTATION(kTaggedPtr)) \
   V(Function,            1 << 12 | REPRESENTATION(kTaggedPtr)) \
   V(RegExp,              1 << 13 | REPRESENTATION(kTaggedPtr)) \
   V(OtherObject,         1 << 14 | REPRESENTATION(kTaggedPtr)) \
   V(Proxy,               1 << 15 | REPRESENTATION(kTaggedPtr)) \
   V(Internal,            1 << 16 | REPRESENTATION(kTagged | kUntagged)) \
   \
-  V(Oddball,             kBoolean | kNull | kUndefined)                 \
   V(Signed32,            kSignedSmall | kOtherSigned32)                 \
   V(Number,              kSigned32 | kUnsigned32 | kFloat)              \
   V(String,              kInternalizedString | kOtherString)            \
   V(UniqueName,          kSymbol | kInternalizedString)                 \
   V(Name,                kSymbol | kString)                             \
   V(NumberOrString,      kNumber | kString)                             \
   V(DetectableObject,    kArray | kFunction | kRegExp | kOtherObject)   \
   V(DetectableReceiver,  kDetectableObject | kProxy)                    \
   V(Detectable,          kDetectableReceiver | kNumber | kName)         \
   V(Object,              kDetectableObject | kUndetectable)             \
   V(Receiver,            kObject | kProxy)                              \
-  V(NonNumber,           kOddball | kName | kReceiver | kInternal)      \
+  V(NonNumber,           kBoolean | kName | kNull | kReceiver |         \
+                         kUndefined | kInternal)                        \
   V(Any,                 kNumber | kNonNumber)
 
 #define BITSET_TYPE_LIST(V) \
   MASK_BITSET_TYPE_LIST(V) \
   REPRESENTATION_BITSET_TYPE_LIST(V) \
   SEMANTIC_BITSET_TYPE_LIST(V)
 
 
 // struct Config {
 //   typedef Base;
@@ skipping 333 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_