From c5f20ef8dc35d2b5e4921ff2422fa105ae97c0cd Mon Sep 17 00:00:00 2001 From: "olivf@chromium.org" Date: Wed, 10 Jul 2013 11:20:00 +0000 Subject: [PATCH] Type::GetName(...) for inspecting Types in the debugger BUG= R=rossberg@chromium.org Review URL: https://codereview.chromium.org/18587007 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@15586 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/types.cc | 46 +++++++++++++++++ src/types.h | 141 +++++++++++++++++++++++++++++---------------------- 2 files changed, 125 insertions(+), 62 deletions(-) diff --git a/src/types.cc b/src/types.cc index ed98480b8..2f856cf9d 100644 --- a/src/types.cc +++ b/src/types.cc @@ -26,6 +26,7 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "types.h" +#include "string-stream.h" namespace v8 { namespace internal { @@ -486,4 +487,49 @@ Representation Representation::FromType(Handle type) { } +#ifdef OBJECT_PRINT +void Type::TypePrint() { + TypePrint(stdout); + PrintF(stdout, "\n"); + Flush(stdout); +} + + +void Type::TypePrint(FILE* out) { + if (is_bitset()) { + int val = as_bitset(); + const char* composed_name = GetComposedName(val); + if (composed_name != NULL) { + PrintF(out, "%s", composed_name); + return; + } + bool first_entry = true; + PrintF(out, "{"); + for (unsigned i = 0; i < sizeof(val)*8; ++i) { + int mask = (1<(*as_constant())); + } else if (is_class()) { + PrintF(out, "Class(%p)", reinterpret_cast(*as_class())); + } else if (is_union()) { + PrintF(out, "{"); + Handle unioned = as_union(); + for (int i = 0; i < unioned->length(); ++i) { + Handle type_i = union_get(unioned, i); + if (i > 0) PrintF(out, ","); + type_i->TypePrint(out); + } + PrintF(out, "}"); + } +} +#endif + + } } // namespace v8::internal diff --git a/src/types.h b/src/types.h index 31aa9512f..bc6e580a7 100644 --- a/src/types.h +++ b/src/types.h @@ -94,39 +94,54 @@ namespace internal { // 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) + +#define COMPOSED_TYPE_LIST(V) \ + V(Oddball, kBoolean | kNull | kUndefined) \ + 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) \ + V(Receiver, kObject | kProxy) \ + V(Allocated, kDouble | kName | kReceiver) \ + V(Any, kOddball | kNumber | kAllocated | kInternal) \ + V(Detectable, kAllocated - kUndetectable) + +#define TYPE_LIST(V) \ + PRIMITIVE_TYPE_LIST(V) \ + COMPOSED_TYPE_LIST(V) + + + 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* 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* Internal() { return from_bitset(kInternal); } + #define DEFINE_TYPE_CONSTRUCTOR(type, value) \ + static Type* type() { return from_bitset(k##type); } + TYPE_LIST(DEFINE_TYPE_CONSTRUCTOR) + #undef DEFINE_TYPE_CONSTRUCTOR static Type* Class(Handle map) { return from_handle(map); } static Type* Constant(Handle value) { @@ -191,6 +206,11 @@ class Type : public Object { return t; } +#ifdef OBJECT_PRINT + void TypePrint(); + void TypePrint(FILE* out); +#endif + private: // A union is a fixed array containing types. Invariants: // - its length is at least 2 @@ -199,37 +219,10 @@ class Type : public Object { 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, - - 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 + #define DECLARE_TYPE(type, value) k##type = (value), + TYPE_LIST(DECLARE_TYPE) + #undef DECLARE_TYPE + kUnusedEOL = 0 }; bool is_bitset() { return this->IsSmi(); } @@ -272,6 +265,30 @@ class Type : public Object { int ExtendUnion(Handle unioned, int current_size); int ExtendIntersection( Handle unioned, Handle type, int current_size); + + static const char* GetComposedName(int type) { + switch (type) { + #define PRINT_COMPOSED_TYPE(type, value) \ + case k##type: \ + return # type; + COMPOSED_TYPE_LIST(PRINT_COMPOSED_TYPE) + #undef PRINT_COMPOSED_TYPE + } + return NULL; + } + + static const char* GetPrimitiveName(int type) { + switch (type) { + #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"; + } + } }; } } // namespace v8::internal -- 2.34.1