Revert "Refactoring to allow adding new structured types"

src/types-inl.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_INL_H_
 #define V8_TYPES_INL_H_
 
 #include "types.h"
 
 #include "factory.h"
 #include "handles-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // static
+ZoneTypeConfig::Tagged* ZoneTypeConfig::tagged_create(
+    Tag tag, int size, Zone* zone) {
+  Tagged* tagged = new(zone) Tagged(size + 1, zone);
+  tagged->Add(reinterpret_cast<void*>(tag), zone);
+  tagged->AddBlock(NULL, size, zone);
+  return tagged;
+}
+
+
+// static
+void ZoneTypeConfig::tagged_shrink(Tagged* tagged, int size) {
+  tagged->Rewind(size + 1);
+}
+
+
+// static
+ZoneTypeConfig::Tag ZoneTypeConfig::tagged_tag(Tagged* tagged) {
+  return static_cast<Tag>(reinterpret_cast<intptr_t>(tagged->at(0)));
+}
+
+
+// static
+template<class T>
+T ZoneTypeConfig::tagged_get(Tagged* tagged, int i) {
+  return reinterpret_cast<T>(tagged->at(i + 1));
+}
+
+
+// static
+template<class T>
+void ZoneTypeConfig::tagged_set(Tagged* tagged, int i, T value) {
+  tagged->at(i + 1) = reinterpret_cast<void*>(value);
+}
+
+
+// static
+int ZoneTypeConfig::tagged_length(Tagged* tagged) {
+  return tagged->length() - 1;
+}
+
+
+// static
 Type* ZoneTypeConfig::handle(Type* type) {
   return type;
 }
 
 
 // static
+bool ZoneTypeConfig::is(Type* type, Tag tag) {
+  return is_tagged(type) && tagged_tag(as_tagged(type)) == tag;
+}
+
+
+// static
 bool ZoneTypeConfig::is_bitset(Type* type) {
   return reinterpret_cast<intptr_t>(type) & 1;
 }
 
 
 // static
-bool ZoneTypeConfig::is_struct(Type* type) {
+bool ZoneTypeConfig::is_tagged(Type* type) {
   return !is_bitset(type);
 }
 
 
 // static
 bool ZoneTypeConfig::is_class(Type* type) {
-  return is_struct(type) && struct_tag(as_struct(type)) == Type::kClassTag;
+  return is(type, kClassTag);
 }
 
 
 // static
 bool ZoneTypeConfig::is_constant(Type* type) {
-  return is_struct(type) && struct_tag(as_struct(type)) == Type::kConstantTag;
+  return is(type, kConstantTag);
 }
 
 
+// static
+bool ZoneTypeConfig::is_union(Type* type) {
+  return is(type, kUnionTag);
+}
+
+
+// static
+bool ZoneTypeConfig::tagged_is_union(Tagged* tagged) {
+  return is(from_tagged(tagged), kUnionTag);
+}
+
+
 // static
 int ZoneTypeConfig::as_bitset(Type* type) {
   ASSERT(is_bitset(type));
   return static_cast<int>(reinterpret_cast<intptr_t>(type) >> 1);
 }
 
 
 // static
-ZoneTypeConfig::Struct* ZoneTypeConfig::as_struct(Type* type) {
-  ASSERT(is_struct(type));
-  return reinterpret_cast<Struct*>(type);
+ZoneTypeConfig::Tagged* ZoneTypeConfig::as_tagged(Type* type) {
+  ASSERT(is_tagged(type));
+  return reinterpret_cast<Tagged*>(type);
 }
 
 
 // static
 i::Handle<i::Map> ZoneTypeConfig::as_class(Type* type) {
   ASSERT(is_class(type));
-  return i::Handle<i::Map>(static_cast<i::Map**>(as_struct(type)->args[1]));
+  return i::Handle<i::Map>(tagged_get<i::Map**>(as_tagged(type), 1));
 }
 
 
 // static
 i::Handle<i::Object> ZoneTypeConfig::as_constant(Type* type) {
   ASSERT(is_constant(type));
-  return i::Handle<i::Object>(
-      static_cast<i::Object**>(as_struct(type)->args[1]));
+  return i::Handle<i::Object>(tagged_get<i::Object**>(as_tagged(type), 1));
 }
 
 
+// static
+ZoneTypeConfig::Unioned* ZoneTypeConfig::as_union(Type* type) {
+  ASSERT(is_union(type));
+  return tagged_as_union(as_tagged(type));
+}
+
+
+// static
+ZoneTypeConfig::Unioned* ZoneTypeConfig::tagged_as_union(Tagged* tagged) {
+  ASSERT(tagged_is_union(tagged));
+  return reinterpret_cast<Unioned*>(tagged);
+}
+
+
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset) {
   return reinterpret_cast<Type*>((bitset << 1) | 1);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_bitset(int bitset, Zone* Zone) {
   return from_bitset(bitset);
 }
 
 
 // static
-ZoneTypeConfig::Type* ZoneTypeConfig::from_struct(Struct* structured) {
-  return reinterpret_cast<Type*>(structured);
+ZoneTypeConfig::Type* ZoneTypeConfig::from_tagged(Tagged* tagged) {
+  return reinterpret_cast<Type*>(tagged);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_class(
     i::Handle<i::Map> map, int lub, Zone* zone) {
-  Struct* structured = struct_create(Type::kClassTag, 2, zone);
-  structured->args[0] = from_bitset(lub);
-  structured->args[1] = map.location();
-  return from_struct(structured);
+  Tagged* tagged = tagged_create(kClassTag, 2, zone);
+  tagged_set(tagged, 0, lub);
+  tagged_set(tagged, 1, map.location());
+  return from_tagged(tagged);
 }
 
 
 // static
 ZoneTypeConfig::Type* ZoneTypeConfig::from_constant(
     i::Handle<i::Object> value, int lub, Zone* zone) {
-  Struct* structured = struct_create(Type::kConstantTag, 2, zone);
-  structured->args[0] = from_bitset(lub);
-  structured->args[1] = value.location();
-  return from_struct(structured);
+  Tagged* tagged = tagged_create(kConstantTag, 2, zone);
+  tagged_set(tagged, 0, lub);
+  tagged_set(tagged, 1, value.location());
+  return from_tagged(tagged);
 }
 
 
 // static
-ZoneTypeConfig::Struct* ZoneTypeConfig::struct_create(
-    int tag, int length, Zone* zone) {
-  Struct* structured = reinterpret_cast<Struct*>(
-      zone->New(sizeof(Struct) + sizeof(void*) * (length - 1)));  // NOLINT
-  structured->tag = tag;
-  structured->length = length;
-  return structured;
+ZoneTypeConfig::Type* ZoneTypeConfig::from_union(Unioned* unioned) {
+  return from_tagged(tagged_from_union(unioned));
 }
 
 
 // static
-void ZoneTypeConfig::struct_shrink(Struct* structured, int length) {
-  ASSERT(0 <= length && length <= structured->length);
-  structured->length = length;
+ZoneTypeConfig::Tagged* ZoneTypeConfig::tagged_from_union(Unioned* unioned) {
+  return reinterpret_cast<Tagged*>(unioned);
 }
 
 
 // static
-int ZoneTypeConfig::struct_tag(Struct* structured) {
-  return structured->tag;
+ZoneTypeConfig::Unioned* ZoneTypeConfig::union_create(int size, Zone* zone) {
+  return tagged_as_union(tagged_create(kUnionTag, size, zone));
 }
 
 
 // static
-Type* ZoneTypeConfig::struct_get(Struct* structured, int i) {
-  ASSERT(0 <= i && i < structured->length);
-  return static_cast<Type*>(structured->args[i]);
+void ZoneTypeConfig::union_shrink(Unioned* unioned, int size) {
+  tagged_shrink(tagged_from_union(unioned), size);
 }
 
 
 // static
-void ZoneTypeConfig::struct_set(Struct* structured, int i, Type* type) {
-  ASSERT(0 <= i && i < structured->length);
-  structured->args[i] = type;
+ZoneTypeConfig::Type* ZoneTypeConfig::union_get(Unioned* unioned, int i) {
+  Type* type = tagged_get<Type*>(tagged_from_union(unioned), i);
+  ASSERT(!is_union(type));
+  return type;
 }
 
 
 // static
-int ZoneTypeConfig::struct_length(Struct* structured) {
-  return structured->length;
+void ZoneTypeConfig::union_set(Unioned* unioned, int i, Type* type) {
+  ASSERT(!is_union(type));
+  tagged_set(tagged_from_union(unioned), i, type);
+}
+
+
+// static
+int ZoneTypeConfig::union_length(Unioned* unioned) {
+  return tagged_length(tagged_from_union(unioned));
 }
 
 
 // static
 int ZoneTypeConfig::lub_bitset(Type* type) {
   ASSERT(is_class(type) || is_constant(type));
-  return as_bitset(struct_get(as_struct(type), 0));
+  return static_cast<int>(tagged_get<intptr_t>(as_tagged(type), 0));
 }
 
 // -------------------------------------------------------------------------- //
 
 // static
 i::Handle<HeapTypeConfig::Type> HeapTypeConfig::handle(Type* type) {
   return i::handle(type, i::HeapObject::cast(type)->GetIsolate());
 }
 
 
 // static
 bool HeapTypeConfig::is_bitset(Type* type) {
   return type->IsSmi();
 }
 
 
 // static
 bool HeapTypeConfig::is_class(Type* type) {
   return type->IsMap();
 }
 
 
 // static
 bool HeapTypeConfig::is_constant(Type* type) {
   return type->IsBox();
 }
 
 
 // static
-bool HeapTypeConfig::is_struct(Type* type) {
+bool HeapTypeConfig::is_union(Type* type) {
   return type->IsFixedArray();
 }
 
 
 // static
 int HeapTypeConfig::as_bitset(Type* type) {
   return Smi::cast(type)->value();
 }
 
 
 // static
 i::Handle<i::Map> HeapTypeConfig::as_class(Type* type) {
   return i::handle(i::Map::cast(type));
 }
 
 
 // static
 i::Handle<i::Object> HeapTypeConfig::as_constant(Type* type) {
   i::Box* box = i::Box::cast(type);
   return i::handle(box->value(), box->GetIsolate());
 }
 
 
 // static
-i::Handle<HeapTypeConfig::Struct> HeapTypeConfig::as_struct(Type* type) {
-  return i::handle(Struct::cast(type));
+i::Handle<HeapTypeConfig::Unioned> HeapTypeConfig::as_union(Type* type) {
+  return i::handle(i::FixedArray::cast(type));
 }
 
 
 // static
 HeapTypeConfig::Type* HeapTypeConfig::from_bitset(int bitset) {
   return Type::cast(i::Smi::FromInt(bitset));
 }
 
 
 // static
@@ skipping 12 matching lines @@
 
 // static
 i::Handle<HeapTypeConfig::Type> HeapTypeConfig::from_constant(
     i::Handle<i::Object> value, int lub, Isolate* isolate) {
   i::Handle<Box> box = isolate->factory()->NewBox(value);
   return i::Handle<Type>::cast(i::Handle<Object>::cast(box));
 }
 
 
 // static
-i::Handle<HeapTypeConfig::Type> HeapTypeConfig::from_struct(
-    i::Handle<Struct> structured) {
-  return i::Handle<Type>::cast(i::Handle<Object>::cast(structured));
+i::Handle<HeapTypeConfig::Type> HeapTypeConfig::from_union(
+    i::Handle<Unioned> unioned) {
+  return i::Handle<Type>::cast(i::Handle<Object>::cast(unioned));
 }
 
 
 // static
-i::Handle<HeapTypeConfig::Struct> HeapTypeConfig::struct_create(
-    int tag, int length, Isolate* isolate) {
-  i::Handle<Struct> structured = isolate->factory()->NewFixedArray(length + 1);
-  structured->set(0, i::Smi::FromInt(tag));
-  return structured;
+i::Handle<HeapTypeConfig::Unioned> HeapTypeConfig::union_create(
+    int size, Isolate* isolate) {
+  return isolate->factory()->NewFixedArray(size);
 }
 
 
 // static
-void HeapTypeConfig::struct_shrink(i::Handle<Struct> structured, int length) {
-  structured->Shrink(length + 1);
+void HeapTypeConfig::union_shrink(i::Handle<Unioned> unioned, int size) {
+  unioned->Shrink(size);
 }
 
 
 // static
-int HeapTypeConfig::struct_tag(i::Handle<Struct> structured) {
-  return static_cast<i::Smi*>(structured->get(0))->value();
+i::Handle<HeapTypeConfig::Type> HeapTypeConfig::union_get(
+    i::Handle<Unioned> unioned, int i) {
+  Type* type = static_cast<Type*>(unioned->get(i));
+  ASSERT(!is_union(type));
+  return i::handle(type, unioned->GetIsolate());
 }
 
 
 // static
-i::Handle<HeapTypeConfig::Type> HeapTypeConfig::struct_get(
-    i::Handle<Struct> structured, int i) {
-  Type* type = static_cast<Type*>(structured->get(i + 1));
-  return i::handle(type, structured->GetIsolate());
+void HeapTypeConfig::union_set(
+    i::Handle<Unioned> unioned, int i, i::Handle<Type> type) {
+  ASSERT(!is_union(*type));
+  unioned->set(i, *type);
 }
 
 
 // static
-void HeapTypeConfig::struct_set(
-    i::Handle<Struct> structured, int i, i::Handle<Type> type) {
-  structured->set(i + 1, *type);
+int HeapTypeConfig::union_length(i::Handle<Unioned> unioned) {
+  return unioned->length();
 }
 
 
-// static
-int HeapTypeConfig::struct_length(i::Handle<Struct> structured) {
-  return structured->length() - 1;
-}
-
-
 // static
 int HeapTypeConfig::lub_bitset(Type* type) {
   return 0;  // kNone, which causes recomputation.
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_INL_H_