Type::GetName() for printing types in debugger

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 76 matching lines @@
 // 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.
 
+
+#define PRIMITIVE_TYPE_LIST(V)           \
+  V(None,                0)              \
+  V(Null,                1 << 0)         \
+  V(Undefined,           1 << 1)         \
+  V(Boolean,             1 << 2)         \
+  V(Smi,                 1 << 3)         \
+  V(OtherSigned32,       1 << 4)         \
+  V(Unsigned32,          1 << 5)         \
+  V(Double,              1 << 6)         \
+  V(Symbol,              1 << 7)         \
+  V(InternalizedString,  1 << 8)         \
+  V(OtherString,         1 << 9)         \
+  V(Undetectable,        1 << 10)        \
+  V(Array,               1 << 11)        \
+  V(Function,            1 << 12)        \
+  V(RegExp,              1 << 13)        \
+  V(OtherObject,         1 << 14)        \
+  V(Proxy,               1 << 15)        \
+  V(Internal,            1 << 16)        \
+  V(Oddball,         kBoolean | kNull | kUndefined)                          \

[rossberg, 2013/07/03 14:52:54]

Nit: Maybe insert an empty line before this one.

+  V(Signed32,        kSmi | kOtherSigned32)                                  \
+  V(Number,          kSigned32 | kUnsigned32 | kDouble)                      \
+  V(String,          kInternalizedString | kOtherString)                     \
+  V(UniqueName,      kSymbol | kInternalizedString)                          \
+  V(Name,            kSymbol | kString)                                      \
+  V(NumberOrString,  kNumber | kString)                                      \
+  V(Object,     kUndetectable | kArray | kFunction | kRegExp | kOtherObject) \

[rossberg, 2013/07/03 14:52:54]

Aha, cheating with indentation!

+  V(Receiver,        kObject | kProxy)                                       \
+  V(Allocated,       kDouble | kName | kReceiver)                            \
+  V(Any,             kOddball | kNumber | kAllocated | kInternal)            \
+  V(Detectable,      kAllocated - kUndetectable)
+
+
 class Type : public Object {
  public:
   static Type* None() { return from_bitset(kNone); }

[rossberg, 2013/07/03 14:52:54]

Can't you generate all these functions from the macro now?

   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); }
@@ skipping 75 matching lines @@
   }
 
  private:
   // 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,
-    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,
-    kInternal = 1 << 16,
+    // Declare const for all primitive types.
+    #define DECLARE_PRIMITIVE_TYPE(type, value) k##type = (value),
+    PRIMITIVE_TYPE_LIST(DECLARE_PRIMITIVE_TYPE)

[rossberg, 2013/07/03 14:52:54]

Nit: maybe indent this by 2

[oliv, 2013/07/05 12:29:06]

i'd rather not, since it looks very strange if the defined macro goes over
multiple lines.

+    #undef DECLARE_OPCODE
+    kUnusedEOL = 0

[rossberg, 2013/07/03 14:52:54]

What's that for?

[oliv, 2013/07/05 12:29:06]

you cannot end the enum definition with a comma...

+  };
 
-    kOddball = kBoolean | kNull | kUndefined,
-    kSigned32 = kSmi | kOtherSigned32,
-    kNumber = kSigned32 | kUnsigned32 | kDouble,
-    kString = kInternalizedString | kOtherString,
-    kUniqueName = kSymbol | kInternalizedString,
-    kName = kSymbol | kString,
-    kNumberOrString = kNumber | kString,
-    kObject = kUndetectable | kArray | kFunction | kRegExp | kOtherObject,
-    kReceiver = kObject | kProxy,
-    kAllocated = kDouble | kName | kReceiver,
-    kAny = kOddball | kNumber | kAllocated | kInternal,
-    kDetectable = kAllocated - kUndetectable,
-    kNone = 0
-  };
+  const char* GetPrimitiveName() {
+    switch (as_bitset()) {

[rossberg, 2013/07/03 14:52:54]

Yeah, that does not fly. Any combination of primitive types represents a valid
(union) type, so you must be able to print all of them.

+      #define PRINT_PRIMITIVE_TYPE(type, value)  \
+      case k##type:                              \
+        return # type;
+      PRIMITIVE_TYPE_LIST(PRINT_PRIMITIVE_TYPE)
+      #undef PRINT_PRIMITIVE_TYPE
+      default:
+        UNREACHABLE();
+        return "InvalidType";
+    }
+  }
 
   bool is_bitset() { return this->IsSmi(); }
   bool is_class() { return this->IsMap(); }
   bool is_constant() { return this->IsBox(); }
   bool is_union() { return this->IsFixedArray(); }
 
   bool IsSlowCase(Type* that);
 
   int as_bitset() { return Smi::cast(this)->value(); }
   Handle<Map> as_class() { return Handle<Map>::cast(handle()); }
@@ skipping 21 matching lines @@
     ASSERT(!type->is_union());
     return type->handle_via_isolate_of(from_handle(unioned));
   }
 
   int LubBitset();  // least upper bound that's a bitset
   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);
+
+  static void PrintName(StringStream* stream, Type* type);
+  static SmartArrayPointer<const char> GetName(Type* type);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_