Refactoring to allow adding new structured types

test/cctest/test-types.cc

 // 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 160 matching lines @@
     UNREACHABLE();
   }
 
  private:
   Region* region_;
 };
 
 
 // Testing auxiliaries (breaking the Type abstraction).
 struct ZoneRep {
-  static bool IsTagged(Type* t, int tag) {
-    return !IsBitset(t)
-        && reinterpret_cast<intptr_t>(AsTagged(t)->at(0)) == tag;
+  struct Struct { int tag; int length; void* args[1]; };
+
+  static bool IsStruct(Type* t, int tag) {
+    return !IsBitset(t) && AsStruct(t)->tag == tag;
   }
   static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) & 1; }
-  static bool IsClass(Type* t) { return IsTagged(t, 0); }
-  static bool IsConstant(Type* t) { return IsTagged(t, 1); }
-  static bool IsUnion(Type* t) { return IsTagged(t, 2); }
+  static bool IsClass(Type* t) { return IsStruct(t, 0); }
+  static bool IsConstant(Type* t) { return IsStruct(t, 1); }
+  static bool IsUnion(Type* t) { return IsStruct(t, 2); }
 
-  static ZoneList<void*>* AsTagged(Type* t) {
-    return reinterpret_cast<ZoneList<void*>*>(t);
+  static Struct* AsStruct(Type* t) {
+    return reinterpret_cast<Struct*>(t);
   }
   static int AsBitset(Type* t) {
     return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
   }
   static Map* AsClass(Type* t) {
-    return *reinterpret_cast<Map**>(AsTagged(t)->at(2));
+    return *static_cast<Map**>(AsStruct(t)->args[1]);
   }
   static Object* AsConstant(Type* t) {
-    return *reinterpret_cast<Object**>(AsTagged(t)->at(2));
+    return *static_cast<Object**>(AsStruct(t)->args[1]);
   }
-  static ZoneList<Type*>* AsUnion(Type* t) {
-    return reinterpret_cast<ZoneList<Type*>*>(AsTagged(t));
+  static Struct* AsUnion(Type* t) {
+    return AsStruct(t);
   }
+  static int Length(Struct* structured) { return structured->length; }
 
   static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
 };
 
 
 struct HeapRep {
+  typedef FixedArray Struct;
+
+  static bool IsStruct(Handle<HeapType> t, int tag) {
+    return t->IsFixedArray() && Smi::cast(AsStruct(t)->get(0))->value() == tag;
+  }
   static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
   static bool IsClass(Handle<HeapType> t) { return t->IsMap(); }
   static bool IsConstant(Handle<HeapType> t) { return t->IsBox(); }
-  static bool IsUnion(Handle<HeapType> t) { return t->IsFixedArray(); }
+  static bool IsUnion(Handle<HeapType> t) { return IsStruct(t, 2); }
 
+  static Struct* AsStruct(Handle<HeapType> t) { return FixedArray::cast(*t); }
   static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value(); }
   static Map* AsClass(Handle<HeapType> t) { return Map::cast(*t); }
   static Object* AsConstant(Handle<HeapType> t) {
     return Box::cast(*t)->value();
   }
-  static FixedArray* AsUnion(Handle<HeapType> t) {
-    return FixedArray::cast(*t);
-  }
+  static Struct* AsUnion(Handle<HeapType> t) { return AsStruct(t); }
+  static int Length(Struct* structured) { return structured->length() - 1; }
 
   static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
 };
 
 
 template<class Type, class TypeHandle, class Region, class Rep>
 struct Tests : Rep {
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
@@ skipping 13 matching lines @@
     CHECK_EQ(Rep::IsUnion(type1), Rep::IsUnion(type2));
     CHECK_EQ(type1->NumClasses(), type2->NumClasses());
     CHECK_EQ(type1->NumConstants(), type2->NumConstants());
     if (Rep::IsBitset(type1)) {
       CHECK_EQ(Rep::AsBitset(type1), Rep::AsBitset(type2));
     } else if (Rep::IsClass(type1)) {
       CHECK_EQ(Rep::AsClass(type1), Rep::AsClass(type2));
     } else if (Rep::IsConstant(type1)) {
       CHECK_EQ(Rep::AsConstant(type1), Rep::AsConstant(type2));
     } else if (Rep::IsUnion(type1)) {
-      CHECK_EQ(Rep::AsUnion(type1)->length(), Rep::AsUnion(type2)->length());
+      CHECK_EQ(
+          Rep::Length(Rep::AsUnion(type1)), Rep::Length(Rep::AsUnion(type2)));
     }
     CHECK(type1->Is(type2));
     CHECK(type2->Is(type1));
   }
 
   void CheckSub(TypeHandle type1, TypeHandle type2) {
     CHECK(type1->Is(type2));
     CHECK(!type2->Is(type1));
     if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
       CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
@@ skipping 619 matching lines @@
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }
 
 
 TEST(Convert) {
   CcTest::InitializeVM();
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }