A64: Synchronize with r18084.

src/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 226 matching lines @@
   } else if (this->is_union()) {
     // All but the first are non-bitsets and thus would yield kNone anyway.
     return union_get(this->as_union(), 0)->GlbBitset();
   } else {
     return kNone;
   }
 }
 
 
 // Most precise _current_ type of a value (usually its class).
-Type* Type::CurrentOf(Handle<i::Object> value) {
+Type* Type::OfCurrently(Handle<i::Object> value) {
   if (value->IsSmi()) return Smi();
   i::Map* map = i::HeapObject::cast(*value)->map();
   if (map->instance_type() == HEAP_NUMBER_TYPE ||
       map->instance_type() == ODDBALL_TYPE) {
     return Type::Of(value);
   }
   return Class(i::handle(map));
 }
 
 
@@ skipping 32 matching lines @@
       if (this->Is(that_i)) return true;
       if (this->is_bitset()) break;  // Fast fail, no other field is a bitset.
     }
     return false;
   }
 
   return false;
 }
 
 
+bool Type::IsCurrently(Type* that) {
+  return this->Is(that) ||
+      (this->is_constant() && that->is_class() &&
+       this->as_constant()->IsHeapObject() &&
+       i::HeapObject::cast(*this->as_constant())->map() == *that->as_class());
+}
+
+
 // Check this overlaps that.
 bool Type::Maybe(Type* that) {
   // Fast path for bitsets.
   if (this->is_bitset()) {
     return (this->as_bitset() & that->LubBitset()) != 0;
   }
   if (that->is_bitset()) {
     return (this->LubBitset() & that->as_bitset()) != 0;
   }
 
@@ skipping 208 matching lines @@
 
 
 #ifdef OBJECT_PRINT
 void Type::TypePrint() {
   TypePrint(stdout);
   PrintF(stdout, "\n");
   Flush(stdout);
 }
 
 
+const char* Type::bitset_name(int bitset) {
+  switch (bitset) {
+    #define PRINT_COMPOSED_TYPE(type, value) case k##type: return #type;
+    BITSET_TYPE_LIST(PRINT_COMPOSED_TYPE)
+    #undef PRINT_COMPOSED_TYPE
+    default:
+      return NULL;
+  }
+}
+
+
 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;
+    int bitset = as_bitset();
+    const char* name = bitset_name(bitset);
+    if (name != NULL) {
+      PrintF(out, "%s", name);
+    } else {
+      bool is_first = true;
+      PrintF(out, "(");
+      for (int mask = 1; mask != 0; mask = mask << 1) {
+        if ((bitset & mask) != 0) {
+          if (!is_first) PrintF(out, " | ");
+          is_first = false;
+          PrintF(out, "%s", bitset_name(mask));
+        }
+      }
+      PrintF(out, ")");
     }
-    bool first_entry = true;
-    PrintF(out, "{");
-    for (unsigned i = 0; i < sizeof(val)*8; ++i) {
-      int mask = (1 << i);
-      if ((val & mask) != 0) {
-        if (!first_entry) PrintF(out, ",");
-        first_entry = false;
-        PrintF(out, "%s", GetPrimitiveName(mask));
-      }
-    }
-    PrintF(out, "}");
   } else if (is_constant()) {
     PrintF(out, "Constant(%p : ", static_cast<void*>(*as_constant()));
     from_bitset(LubBitset())->TypePrint(out);
     PrintF(")");
   } else if (is_class()) {
     PrintF(out, "Class(%p < ", static_cast<void*>(*as_class()));
     from_bitset(LubBitset())->TypePrint(out);
     PrintF(")");
   } else if (is_union()) {
-    PrintF(out, "{");
+    PrintF(out, "(");
     Handle<Unioned> unioned = as_union();
     for (int i = 0; i < unioned->length(); ++i) {
       Handle<Type> type_i = union_get(unioned, i);
-      if (i > 0) PrintF(out, ",");
+      if (i > 0) PrintF(out, " | ");
       type_i->TypePrint(out);
     }
-    PrintF(out, "}");
+    PrintF(out, ")");
   }
 }
 #endif
 
 
 } }  // namespace v8::internal