Introduce Unsigned32 and RegExp types

src/types.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 30 matching lines @@
 // 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).
 //
 // The following equations and inequations hold:
 //
 //   None <= T
 //   T <= Any
 //
 //   Oddball = Boolean \/ Null \/ Undefined
-//   Number = Integer32 \/ Double
-//   Integer31 < Integer32
+//   Number = Signed32 \/ Unsigned32 \/ Double
+//   Smi <= Signed32
 //   Name = String \/ Symbol
 //   UniqueName = InternalizedString \/ Symbol
 //   InternalizedString < String
 //
 //   Allocated = Receiver \/ Number \/ Name
 //   Detectable = Allocated - Undetectable
 //   Undetectable < Object
 //   Receiver = Object \/ Proxy
 //   Array < Object
 //   Function < Object
+//   RegExp < Object
 //
 //   Class(map) < T   iff instance_type(map) < T
 //   Constant(x) < T  iff instance_type(map(x)) < T
 //
 // Note that Constant(x) < Class(map(x)) does _not_ hold, since x's map can
 // change! (Its instance type cannot, however.)
 // TODO(rossberg): the latter is not currently true for proxies, because of fix,
 // but will hold once we implement direct proxies.
 //
 // There are two main functions for testing types:
 //
 //   T1->Is(T2)     -- tests whether T1 is included in T2 (i.e., T1 <= T2)
 //   T1->Maybe(T2)  -- tests whether T1 and T2 overlap (i.e., T1 /\ T2 =/= 0)
 //
 // Typically, the former is to be used to select representations (e.g., via
 // T->Is(Integer31())), and the to check whether a specific case needs handling
 // (e.g., via T->Maybe(Number())).
 //
 // There is no functionality to discover whether a type is a leaf in the
 // lattice. That is intentional. It should always be possible to refine the
 // lattice (e.g., splitting up number types further) without invalidating any
 // existing assumptions or tests.
 //
+// Consequently, do not use pointer equality for type tests, always use Is!
+//
 // Internally, all 'primitive' types, and their unions, are represented as
 // bitsets via smis. Class is a heap pointer to the respective map. Only
 // Constant's, or unions containing Class'es or Constant's, require allocation.
 // Note that the bitset representation is closed under both Union and Intersect.
 //
 // The type representation is heap-allocated, so cannot (currently) be used in
 // a parallel compilation context.
 
 class Type : public Object {
  public:
   static Type* None() { return from_bitset(kNone); }
   static Type* Any() { return from_bitset(kAny); }
   static Type* Allocated() { return from_bitset(kAllocated); }
   static Type* Detectable() { return from_bitset(kDetectable); }
 
   static Type* Oddball() { return from_bitset(kOddball); }
   static Type* Boolean() { return from_bitset(kBoolean); }
   static Type* Null() { return from_bitset(kNull); }
   static Type* Undefined() { return from_bitset(kUndefined); }
 
   static Type* Number() { return from_bitset(kNumber); }
-  static Type* Integer31() { return from_bitset(kInteger31); }
-  static Type* Integer32() { return from_bitset(kInteger32); }
+  static Type* Smi() { return from_bitset(kSmi); }
+  static Type* Signed32() { return from_bitset(kSigned32); }
+  static Type* Unsigned32() { return from_bitset(kUnsigned32); }
   static Type* Double() { return from_bitset(kDouble); }
+  static Type* NumberOrString() { return from_bitset(kNumberOrString); }
 
   static Type* Name() { return from_bitset(kName); }
   static Type* UniqueName() { return from_bitset(kUniqueName); }
   static Type* String() { return from_bitset(kString); }
   static Type* InternalizedString() { return from_bitset(kInternalizedString); }
   static Type* Symbol() { return from_bitset(kSymbol); }
 
   static Type* Receiver() { return from_bitset(kReceiver); }
   static Type* Object() { return from_bitset(kObject); }
   static Type* Undetectable() { return from_bitset(kUndetectable); }
   static Type* Array() { return from_bitset(kArray); }
   static Type* Function() { return from_bitset(kFunction); }
+  static Type* RegExp() { return from_bitset(kRegExp); }
   static Type* Proxy() { return from_bitset(kProxy); }
 
   static Type* Class(Handle<Map> map) { return from_handle(map); }
   static Type* Constant(Handle<HeapObject> value) {
     return Constant(value, value->GetIsolate());
   }
   static Type* Constant(Handle<v8::internal::Object> value, Isolate* isolate) {
     return from_handle(isolate->factory()->NewBox(value));
   }
 
@@ skipping 49 matching lines @@
   // A union is a fixed array containing types. Invariants:
   // - its length is at least 2
   // - at most one field is a bitset, and it must go into index 0
   // - no field is a union
   typedef FixedArray Unioned;
 
   enum {
     kNull = 1 << 0,
     kUndefined = 1 << 1,
     kBoolean = 1 << 2,
-    kInteger31 = 1 << 3,
-    kOtherInteger = 1 << 4,
-    kDouble = 1 << 5,
-    kSymbol = 1 << 6,
-    kInternalizedString = 1 << 7,
-    kOtherString = 1 << 8,
-    kUndetectable = 1 << 9,
-    kArray = 1 << 10,
-    kFunction = 1 << 11,
-    kOtherObject = 1 << 12,
-    kProxy = 1 << 13,
+    kSmi = 1 << 3,
+    kOtherSigned32 = 1 << 4,
+    kUnsigned32 = 1 << 5,
+    kDouble = 1 << 6,
+    kSymbol = 1 << 7,
+    kInternalizedString = 1 << 8,
+    kOtherString = 1 << 9,
+    kUndetectable = 1 << 10,
+    kArray = 1 << 11,
+    kFunction = 1 << 12,
+    kRegExp = 1 << 13,
+    kOtherObject = 1 << 14,
+    kProxy = 1 << 15,
 
     kOddball = kBoolean | kNull | kUndefined,
-    kInteger32 = kInteger31 | kOtherInteger,
-    kNumber = kInteger32 | kDouble,
+    kSigned32 = kSmi | kOtherSigned32,
+    kNumber = kSigned32 | kUnsigned32 | kDouble,
     kString = kInternalizedString | kOtherString,
     kUniqueName = kSymbol | kInternalizedString,
     kName = kSymbol | kString,
-    kObject = kUndetectable | kArray | kFunction | kOtherObject,
+    kNumberOrString = kNumber | kString,
+    kObject = kUndetectable | kArray | kFunction | kRegExp | kOtherObject,
     kReceiver = kObject | kProxy,
     kAllocated = kDouble | kName | kReceiver,
     kAny = kOddball | kNumber | kAllocated,
     kDetectable = kAllocated - kUndetectable,
     kNone = 0
   };
 
   bool is_bitset() { return this->IsSmi(); }
   bool is_class() { return this->IsMap(); }
   bool is_constant() { return this->IsBox(); }
@@ skipping 30 matching lines @@
   int GlbBitset();  // greatest lower bound that's a bitset
   bool InUnion(Handle<Unioned> unioned, int current_size);
   int ExtendUnion(Handle<Unioned> unioned, int current_size);
   int ExtendIntersection(
       Handle<Unioned> unioned, Handle<Type> type, int current_size);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_