Fix symmetry of Maybe() predicate. Fix bug in NowContains() predicate.

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 {
@@ skipping 288 matching lines @@
     }
     return false;
   }
 
   return false;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::NowIs(TypeImpl* that) {
-  if (this->Is(that)) return true;
-  if (this->IsConstant() && this->AsConstant()->IsHeapObject()) {
-    i::Handle<i::Map> map(i::HeapObject::cast(*this->AsConstant())->map());
-    for (Iterator<i::Map> it = that->Classes(); !it.Done(); it.Advance()) {
-      if (*it.Current() == *map) return true;
+  if (this->IsConstant()) {
+    DisallowHeapAllocation no_allocation;
+    i::Object* object = *this->AsConstant();
+    if (object->IsHeapObject()) {
+      i::Map* map = i::HeapObject::cast(object)->map();
+      for (Iterator<i::Map> it = that->Classes(); !it.Done(); it.Advance()) {
+        if (*it.Current() == map) return true;
+      }
     }
   }
-  return false;
+  return this->Is(that);
 }
 
 
 // Check this overlaps that.
 template<class Config>
 bool TypeImpl<Config>::Maybe(TypeImpl* that) {
-  // 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()) {
     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()) {
     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->IsBitset()) {
+    return IsInhabited(this->AsBitset() & that->LubBitset());
+  }
+  if (that->IsBitset()) {
+    return IsInhabited(this->LubBitset() & that->AsBitset());
+  }
+
   if (this->IsClass()) {
     return that->IsClass() && *this->AsClass() == *that->AsClass();
   }
   if (this->IsConstant()) {
     return that->IsConstant() && *this->AsConstant() == *that->AsConstant();
   }
 
   return false;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Contains(i::Object* value) {
   for (Iterator<i::Object> it = this->Constants(); !it.Done(); it.Advance()) {
     if (*it.Current() == value) return true;
   }
   return Config::from_bitset(LubBitset(value))->Is(this);
 }
 
 
 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());
+  if (value->IsHeapObject()) {
+    DisallowHeapAllocation no_allocation;
+    i::Map* map = i::HeapObject::cast(value)->map();
+    for (Iterator<i::Map> it = this->Classes(); !it.Done(); it.Advance()) {
+      if (*it.Current() == map) return true;
+    }
+  }
+  return this->Contains(value);
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::InUnion(StructHandle unioned, int current_size) {
   ASSERT(!this->IsUnion());
   for (int i = 0; i < current_size; ++i) {
     TypeHandle type = Config::struct_get(unioned, i);
     if (this->Is(type)) return true;
   }
@@ skipping 294 matching lines @@
 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