Refactoring to allow adding new structured types

src/types.cc

 // 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.
 
 #include "types.h"
 
 #include "string-stream.h"
 #include "types-inl.h"
 
 namespace v8 {
 namespace internal {
 
 template<class Config>
 int TypeImpl<Config>::NumClasses() {
   if (this->IsClass()) {
     return 1;
   } else if (this->IsUnion()) {
-    UnionedHandle unioned = this->AsUnion();
+    StructHandle unioned = this->AsUnion();
     int result = 0;
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      if (Config::union_get(unioned, i)->IsClass()) ++result;
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      if (Config::struct_get(unioned, i)->IsClass()) ++result;
     }
     return result;
   } else {
     return 0;
   }
 }
 
 
 template<class Config>
 int TypeImpl<Config>::NumConstants() {
   if (this->IsConstant()) {
     return 1;
   } else if (this->IsUnion()) {
-    UnionedHandle unioned = this->AsUnion();
+    StructHandle unioned = this->AsUnion();
     int result = 0;
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      if (Config::union_get(unioned, i)->IsConstant()) ++result;
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      if (Config::struct_get(unioned, i)->IsConstant()) ++result;
     }
     return result;
   } else {
     return 0;
   }
 }
 
 
 template<class Config> template<class T>
 typename TypeImpl<Config>::TypeHandle
 TypeImpl<Config>::Iterator<T>::get_type() {
   ASSERT(!Done());
-  return type_->IsUnion() ? Config::union_get(type_->AsUnion(), index_) : type_;
+  return type_->IsUnion()
+      ? Config::struct_get(type_->AsUnion(), index_) : type_;
 }
 
 
 // C++ cannot specialise nested templates, so we have to go through this
 // contortion with an auxiliary template to simulate it.
 template<class Config, class T>
 struct TypeImplIteratorAux {
   static bool matches(typename TypeImpl<Config>::TypeHandle type);
   static i::Handle<T> current(typename TypeImpl<Config>::TypeHandle type);
 };
@@ skipping 27 matching lines @@
 template<class Config> template<class T>
 i::Handle<T> TypeImpl<Config>::Iterator<T>::Current() {
   return TypeImplIteratorAux<Config, T>::current(get_type());
 }
 
 
 template<class Config> template<class T>
 void TypeImpl<Config>::Iterator<T>::Advance() {
   ++index_;
   if (type_->IsUnion()) {
-    UnionedHandle unioned = type_->AsUnion();
-    for (; index_ < Config::union_length(unioned); ++index_) {
-      if (matches(Config::union_get(unioned, index_))) return;
+    StructHandle unioned = type_->AsUnion();
+    for (; index_ < Config::struct_length(unioned); ++index_) {
+      if (matches(Config::struct_get(unioned, index_))) return;
     }
   } else if (index_ == 0 && matches(type_)) {
     return;
   }
   index_ = -1;
 }
 
 
 // Get the smallest bitset subsuming this type.
 template<class Config>
 int TypeImpl<Config>::LubBitset() {
   if (this->IsBitset()) {
     return this->AsBitset();
   } else if (this->IsUnion()) {
-    UnionedHandle unioned = this->AsUnion();
+    StructHandle unioned = this->AsUnion();
     int bitset = kNone;
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      bitset |= Config::union_get(unioned, i)->LubBitset();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      bitset |= Config::struct_get(unioned, i)->LubBitset();
     }
     return bitset;
   } else if (this->IsClass()) {
     int bitset = Config::lub_bitset(this);
     return bitset ? bitset : LubBitset(*this->AsClass());
   } else {
     int bitset = Config::lub_bitset(this);
     return bitset ? bitset : LubBitset(*this->AsConstant());
   }
 }
@@ skipping 102 matching lines @@
 }
 
 
 // Get the largest bitset subsumed by this type.
 template<class Config>
 int TypeImpl<Config>::GlbBitset() {
   if (this->IsBitset()) {
     return this->AsBitset();
   } else if (this->IsUnion()) {
     // All but the first are non-bitsets and thus would yield kNone anyway.
-    return Config::union_get(this->AsUnion(), 0)->GlbBitset();
+    return Config::struct_get(this->AsUnion(), 0)->GlbBitset();
   } else {
     return kNone;
   }
 }
 
 
 // Most precise _current_ type of a value (usually its class).
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::NowOf(
     i::Object* value, Region* region) {
@@ skipping 17 matching lines @@
 
   if (that->IsClass()) {
     return this->IsClass() && *this->AsClass() == *that->AsClass();
   }
   if (that->IsConstant()) {
     return this->IsConstant() && *this->AsConstant() == *that->AsConstant();
   }
 
   // (T1 \/ ... \/ Tn) <= T  <=>  (T1 <= T) /\ ... /\ (Tn <= T)
   if (this->IsUnion()) {
-    UnionedHandle unioned = this->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle this_i = Config::union_get(unioned, i);
+    StructHandle unioned = this->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle this_i = Config::struct_get(unioned, i);
       if (!this_i->Is(that)) return false;
     }
     return true;
   }
 
   // T <= (T1 \/ ... \/ Tn)  <=>  (T <= T1) \/ ... \/ (T <= Tn)
   // (iff T is not a union)
   ASSERT(!this->IsUnion());
   if (that->IsUnion()) {
-    UnionedHandle unioned = that->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle that_i = Config::union_get(unioned, i);
+    StructHandle unioned = that->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle that_i = Config::struct_get(unioned, i);
       if (this->Is(that_i)) return true;
       if (this->IsBitset()) break;  // Fast fail, only first field is a bitset.
     }
     return false;
   }
 
   return false;
 }
 
 
@@ skipping 12 matching lines @@
   // Fast path for bitsets.
   if (this->IsBitset()) {
     return IsInhabited(this->AsBitset() & that->LubBitset());
   }
   if (that->IsBitset()) {
     return IsInhabited(this->LubBitset() & that->AsBitset());
   }
 
   // (T1 \/ ... \/ Tn) overlaps T <=> (T1 overlaps T) \/ ... \/ (Tn overlaps T)
   if (this->IsUnion()) {
-    UnionedHandle unioned = this->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle this_i = Config::union_get(unioned, i);
+    StructHandle unioned = this->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle this_i = Config::struct_get(unioned, i);
       if (this_i->Maybe(that)) return true;
     }
     return false;
   }
 
   // T overlaps (T1 \/ ... \/ Tn) <=> (T overlaps T1) \/ ... \/ (T overlaps Tn)
   if (that->IsUnion()) {
-    UnionedHandle unioned = that->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle that_i = Config::union_get(unioned, i);
+    StructHandle unioned = that->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle that_i = Config::struct_get(unioned, i);
       if (this->Maybe(that_i)) return true;
     }
     return false;
   }
 
   ASSERT(!this->IsUnion() && !that->IsUnion());
   if (this->IsClass()) {
     return that->IsClass() && *this->AsClass() == *that->AsClass();
   }
   if (this->IsConstant()) {
@@ skipping 15 matching lines @@
 
 template<class Config>
 bool TypeImpl<Config>::NowContains(i::Object* value) {
   return this->Contains(value) ||
       (this->IsClass() && value->IsHeapObject() &&
        *this->AsClass() == i::HeapObject::cast(value)->map());
 }
 
 
 template<class Config>
-bool TypeImpl<Config>::InUnion(UnionedHandle unioned, int current_size) {
+bool TypeImpl<Config>::InUnion(StructHandle unioned, int current_size) {
   ASSERT(!this->IsUnion());
   for (int i = 0; i < current_size; ++i) {
-    TypeHandle type = Config::union_get(unioned, i);
+    TypeHandle type = Config::struct_get(unioned, i);
     if (this->Is(type)) return true;
   }
   return false;
 }
 
 
-// Get non-bitsets from this which are not subsumed by union, store at unioned,
+// Get non-bitsets from this which are not subsumed by union, store at result,
 // starting at index. Returns updated index.
 template<class Config>
 int TypeImpl<Config>::ExtendUnion(
-    UnionedHandle result, TypeHandle type, int current_size) {
+    StructHandle result, TypeHandle type, int current_size) {
   int old_size = current_size;
   if (type->IsClass() || type->IsConstant()) {
     if (!type->InUnion(result, old_size)) {
-      Config::union_set(result, current_size++, type);
+      Config::struct_set(result, current_size++, type);
     }
   } else if (type->IsUnion()) {
-    UnionedHandle unioned = type->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle type = Config::union_get(unioned, i);
+    StructHandle unioned = type->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle type = Config::struct_get(unioned, i);
       ASSERT(i == 0 ||
-             !(type->IsBitset() || type->Is(Config::union_get(unioned, 0))));
+             !(type->IsBitset() || type->Is(Config::struct_get(unioned, 0))));
       if (!type->IsBitset() && !type->InUnion(result, old_size)) {
-        Config::union_set(result, current_size++, type);
+        Config::struct_set(result, current_size++, type);
       }
     }
   }
   return current_size;
 }
 
 
 // Union is O(1) on simple bit unions, but O(n*m) on structured unions.
-// TODO(rossberg): Should we use object sets somehow? Is it worth it?
 template<class Config>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Union(
     TypeHandle type1, TypeHandle type2, Region* region) {
   // Fast case: bit sets.
   if (type1->IsBitset() && type2->IsBitset()) {
     return Config::from_bitset(type1->AsBitset() | type2->AsBitset(), region);
   }
 
   // Fast case: top or bottom types.
   if (type1->IsAny() || type2->IsNone()) return type1;
   if (type2->IsAny() || type1->IsNone()) return type2;
 
   // Semi-fast case: Unioned objects are neither involved nor produced.
   if (!(type1->IsUnion() || type2->IsUnion())) {
     if (type1->Is(type2)) return type2;
     if (type2->Is(type1)) return type1;
   }
 
   // Slow case: may need to produce a Unioned object.
   int size = 0;
   if (!type1->IsBitset()) {
-    size += (type1->IsUnion() ? Config::union_length(type1->AsUnion()) : 1);
+    size += (type1->IsUnion() ? Config::struct_length(type1->AsUnion()) : 1);
   }
   if (!type2->IsBitset()) {
-    size += (type2->IsUnion() ? Config::union_length(type2->AsUnion()) : 1);
+    size += (type2->IsUnion() ? Config::struct_length(type2->AsUnion()) : 1);
   }
   int bitset = type1->GlbBitset() | type2->GlbBitset();
   if (IsInhabited(bitset)) ++size;
   ASSERT(size >= 1);
-  UnionedHandle unioned = Config::union_create(size, region);
+  StructHandle unioned = Config::struct_create(kUnionTag, size, region);
 
   size = 0;
   if (IsInhabited(bitset)) {
-    Config::union_set(unioned, size++, Config::from_bitset(bitset, region));
+    Config::struct_set(unioned, size++, Config::from_bitset(bitset, region));
   }
   size = ExtendUnion(unioned, type1, size);
   size = ExtendUnion(unioned, type2, size);
 
   if (size == 1) {
-    return Config::union_get(unioned, 0);
+    return Config::struct_get(unioned, 0);
   } else {
-    Config::union_shrink(unioned, size);
-    return Config::from_union(unioned);
+    Config::struct_shrink(unioned, size);
+    return Config::from_struct(unioned);
   }
 }
 
 
-// Get non-bitsets from type which are also in other, store at unioned,
+// Get non-bitsets from type which are also in other, store at result,
 // starting at index. Returns updated index.
 template<class Config>
 int TypeImpl<Config>::ExtendIntersection(
-    UnionedHandle result, TypeHandle type, TypeHandle other, int current_size) {
+    StructHandle result, TypeHandle type, TypeHandle other, int current_size) {
   int old_size = current_size;
   if (type->IsClass() || type->IsConstant()) {
     if (type->Is(other) && !type->InUnion(result, old_size)) {
-      Config::union_set(result, current_size++, type);
+      Config::struct_set(result, current_size++, type);
     }
   } else if (type->IsUnion()) {
-    UnionedHandle unioned = type->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle type = Config::union_get(unioned, i);
+    StructHandle unioned = type->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle type = Config::struct_get(unioned, i);
       ASSERT(i == 0 ||
-             !(type->IsBitset() || type->Is(Config::union_get(unioned, 0))));
+             !(type->IsBitset() || type->Is(Config::struct_get(unioned, 0))));
       if (!type->IsBitset() && type->Is(other) &&
           !type->InUnion(result, old_size)) {
-        Config::union_set(result, current_size++, type);
+        Config::struct_set(result, current_size++, type);
       }
     }
   }
   return current_size;
 }
 
 
 // Intersection is O(1) on simple bit unions, but O(n*m) on structured unions.
 // TODO(rossberg): Should we use object sets somehow? Is it worth it?
 template<class Config>
@@ skipping 10 matching lines @@
 
   // Semi-fast case: Unioned objects are neither involved nor produced.
   if (!(type1->IsUnion() || type2->IsUnion())) {
     if (type1->Is(type2)) return type1;
     if (type2->Is(type1)) return type2;
   }
 
   // Slow case: may need to produce a Unioned object.
   int size = INT_MAX;
   if (!type1->IsBitset()) {
-    size = (type1->IsUnion() ? Config::union_length(type1->AsUnion()) : 1);
+    size = (type1->IsUnion() ? Config::struct_length(type1->AsUnion()) : 1);
   }
   if (!type2->IsBitset()) {
     size = Min(size,
-               type2->IsUnion() ? Config::union_length(type2->AsUnion()) : 1);
+               type2->IsUnion() ? Config::struct_length(type2->AsUnion()) : 1);
   }
   int bitset = type1->GlbBitset() & type2->GlbBitset();
   if (IsInhabited(bitset)) ++size;
   ASSERT(size >= 1);
-  UnionedHandle unioned = Config::union_create(size, region);
+  StructHandle unioned = Config::struct_create(kUnionTag, size, region);
 
   size = 0;
   if (IsInhabited(bitset)) {
-    Config::union_set(unioned, size++, Config::from_bitset(bitset, region));
+    Config::struct_set(unioned, size++, Config::from_bitset(bitset, region));
   }
   size = ExtendIntersection(unioned, type1, type2, size);
   size = ExtendIntersection(unioned, type2, type1, size);
 
   if (size == 0) {
     return None(region);
   } else if (size == 1) {
-    return Config::union_get(unioned, 0);
+    return Config::struct_get(unioned, 0);
   } else {
-    Config::union_shrink(unioned, size);
-    return Config::from_union(unioned);
+    Config::struct_shrink(unioned, size);
+    return Config::from_struct(unioned);
   }
 }
 
 
 template<class Config>
 template<class OtherType>
 typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Convert(
     typename OtherType::TypeHandle type, Region* region) {
   if (type->IsBitset()) {
     return Config::from_bitset(type->AsBitset(), region);
   } else if (type->IsClass()) {
     return Config::from_class(type->AsClass(), type->LubBitset(), region);
   } else if (type->IsConstant()) {
     return Config::from_constant(type->AsConstant(), type->LubBitset(), region);
   } else {
     ASSERT(type->IsUnion());
-    typename OtherType::UnionedHandle unioned = type->AsUnion();
-    int length = OtherType::UnionLength(unioned);
-    UnionedHandle new_unioned = Config::union_create(length, region);
+    typename OtherType::StructHandle unioned = type->AsUnion();
+    int length = OtherType::StructLength(unioned);
+    StructHandle new_unioned = Config::struct_create(kUnionTag, length, region);
     for (int i = 0; i < length; ++i) {
-      Config::union_set(new_unioned, i,
-          Convert<OtherType>(OtherType::UnionGet(unioned, i), region));
+      Config::struct_set(new_unioned, i,
+          Convert<OtherType>(OtherType::StructGet(unioned, i), region));
     }
-    return Config::from_union(new_unioned);
+    return Config::from_struct(new_unioned);
   }
 }
 
 
 // TODO(rossberg): this does not belong here.
 Representation Representation::FromType(Type* type) {
   if (type->Is(Type::None())) return Representation::None();
   if (type->Is(Type::SignedSmall())) return Representation::Smi();
   if (type->Is(Type::Signed32())) return Representation::Integer32();
   if (type->Is(Type::Number())) return Representation::Double();
@@ skipping 83 matching lines @@
   } else if (this->IsConstant()) {
     PrintF(out, "Constant(%p : ", static_cast<void*>(*this->AsConstant()));
     Config::from_bitset(this->LubBitset())->TypePrint(out);
     PrintF(out, ")");
   } else if (this->IsClass()) {
     PrintF(out, "Class(%p < ", static_cast<void*>(*this->AsClass()));
     Config::from_bitset(this->LubBitset())->TypePrint(out);
     PrintF(out, ")");
   } else if (this->IsUnion()) {
     PrintF(out, "(");
-    UnionedHandle unioned = this->AsUnion();
-    for (int i = 0; i < Config::union_length(unioned); ++i) {
-      TypeHandle type_i = Config::union_get(unioned, i);
+    StructHandle unioned = this->AsUnion();
+    for (int i = 0; i < Config::struct_length(unioned); ++i) {
+      TypeHandle type_i = Config::struct_get(unioned, i);
       if (i > 0) PrintF(out, " | ");
       type_i->TypePrint(out, dim);
     }
     PrintF(out, ")");
   }
 }
 #endif
 
 
 template class TypeImpl<ZoneTypeConfig>;
 template class TypeImpl<ZoneTypeConfig>::Iterator<i::Map>;
 template class TypeImpl<ZoneTypeConfig>::Iterator<i::Object>;
 
 template class TypeImpl<HeapTypeConfig>;
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Map>;
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal