A64: Synchronize with r18084.

src/ic.cc

Index: src/ic.cc
diff --git a/src/ic.cc b/src/ic.cc
index 53c103a89989074790fd0a839d978763d4202825..c22f3c17d095af80825c45981b708c3a3ecc1177 100644
--- a/src/ic.cc
+++ b/src/ic.cc
@@ -783,7 +783,7 @@ void CallICBase::UpdateCaches(LookupResult* lookup,
       : Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate())),
                          isolate());
 
-  PatchCache(handle(Type::CurrentOf(cache_object), isolate()), name, code);
+  PatchCache(CurrentTypeOf(cache_object, isolate()), name, code);
   TRACE_IC("CallIC", name);
 }
 
@@ -989,7 +989,7 @@ bool IC::UpdatePolymorphicIC(Handle<Type> type,
     // If the receiver type is already in the polymorphic IC, this indicates
     // there was a prototoype chain failure. In that case, just overwrite the
     // handler.
-    } else if (type->Is(current_type)) {
+    } else if (type->IsCurrently(current_type)) {
       ASSERT(handler_to_overwrite == -1);
       number_of_valid_types--;
       handler_to_overwrite = i;
@@ -1015,9 +1015,20 @@ bool IC::UpdatePolymorphicIC(Handle<Type> type,
 }
 
 
+Handle<Type> IC::CurrentTypeOf(Handle<Object> object, Isolate* isolate) {
+  Type* type = object->IsJSGlobalObject()
+      ? Type::Constant(Handle<JSGlobalObject>::cast(object))
+      : Type::OfCurrently(object);
+  return handle(type, isolate);
+}
+
+
 Handle<Map> IC::TypeToMap(Type* type, Isolate* isolate) {
   if (type->Is(Type::Number())) return isolate->factory()->heap_number_map();
   if (type->Is(Type::Boolean())) return isolate->factory()->oddball_map();
+  if (type->IsConstant()) {
+    return handle(Handle<JSGlobalObject>::cast(type->AsConstant())->map());
+  }
   ASSERT(type->IsClass());
   return type->AsClass();
 }
@@ -1134,13 +1145,14 @@ void LoadIC::UpdateCaches(LookupResult* lookup,
     return;
   }
 
+  Handle<Type> type = CurrentTypeOf(object, isolate());
   Handle<Code> code;
   if (!lookup->IsCacheable()) {
     // Bail out if the result is not cacheable.
     code = slow_stub();
   } else if (!lookup->IsProperty()) {
     if (kind() == Code::LOAD_IC) {
-      code = isolate()->stub_cache()->ComputeLoadNonexistent(name, object);
+      code = isolate()->stub_cache()->ComputeLoadNonexistent(name, type);
     } else {
       code = slow_stub();
     }
@@ -1148,7 +1160,7 @@ void LoadIC::UpdateCaches(LookupResult* lookup,
     code = ComputeHandler(lookup, object, name);
   }
 
-  PatchCache(handle(Type::CurrentOf(object), isolate()), name, code);
+  PatchCache(type, name, code);
   TRACE_IC("LoadIC", name);
 }
 
@@ -1170,7 +1182,7 @@ Handle<Code> IC::ComputeHandler(LookupResult* lookup,
       isolate(), *object, cache_holder));
 
   Handle<Code> code = isolate()->stub_cache()->FindHandler(
-      name, stub_holder, kind(), cache_holder, strict_mode());
+      name, handle(stub_holder->map()), kind(), cache_holder, strict_mode());
   if (!code.is_null()) return code;
 
   code = CompileHandler(lookup, object, name, value, cache_holder);
@@ -1194,6 +1206,7 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
     return SimpleFieldLoad(length_index);
   }
 
+  Handle<Type> type = CurrentTypeOf(object, isolate());
   Handle<JSObject> holder(lookup->holder());
   LoadStubCompiler compiler(isolate(), cache_holder, kind());
 
@@ -1206,14 +1219,14 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
                                lookup->representation());
       }
       return compiler.CompileLoadField(
-          object, holder, name, field, lookup->representation());
+          type, holder, name, field, lookup->representation());
     }
     case CONSTANT: {
       Handle<Object> constant(lookup->GetConstant(), isolate());
       // TODO(2803): Don't compute a stub for cons strings because they cannot
       // be embedded into code.
       if (constant->IsConsString()) break;
-      return compiler.CompileLoadConstant(object, holder, name, constant);
+      return compiler.CompileLoadConstant(type, holder, name, constant);
     }
     case NORMAL:
       if (kind() != Code::LOAD_IC) break;
@@ -1222,7 +1235,7 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
         Handle<PropertyCell> cell(
             global->GetPropertyCell(lookup), isolate());
         Handle<Code> code = compiler.CompileLoadGlobal(
-            object, global, cell, name, lookup->IsDontDelete());
+            type, global, cell, name, lookup->IsDontDelete());
         // TODO(verwaest): Move caching of these NORMAL stubs outside as well.
         Handle<HeapObject> stub_holder(GetCodeCacheHolder(
             isolate(), *object, cache_holder));
@@ -1252,7 +1265,7 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
             Handle<ExecutableAccessorInfo>::cast(callback);
         if (v8::ToCData<Address>(info->getter()) == 0) break;
         if (!info->IsCompatibleReceiver(*object)) break;
-        return compiler.CompileLoadCallback(object, holder, name, info);
+        return compiler.CompileLoadCallback(type, holder, name, info);
       } else if (callback->IsAccessorPair()) {
         Handle<Object> getter(Handle<AccessorPair>::cast(callback)->getter(),
                               isolate());
@@ -1271,9 +1284,9 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
         if (call_optimization.is_simple_api_call() &&
             call_optimization.IsCompatibleReceiver(*object)) {
           return compiler.CompileLoadCallback(
-              object, holder, name, call_optimization);
+              type, holder, name, call_optimization);
         }
-        return compiler.CompileLoadViaGetter(object, holder, name, function);
+        return compiler.CompileLoadViaGetter(type, holder, name, function);
       }
       // TODO(dcarney): Handle correctly.
       if (callback->IsDeclaredAccessorInfo()) break;
@@ -1283,7 +1296,7 @@ Handle<Code> LoadIC::CompileHandler(LookupResult* lookup,
     }
     case INTERCEPTOR:
       ASSERT(HasInterceptorGetter(*holder));
-      return compiler.CompileLoadInterceptor(object, holder, name);
+      return compiler.CompileLoadInterceptor(type, holder, name);
     default:
       break;
   }
@@ -1609,7 +1622,7 @@ void StoreIC::UpdateCaches(LookupResult* lookup,
 
   Handle<Code> code = ComputeHandler(lookup, receiver, name, value);
 
-  PatchCache(handle(Type::CurrentOf(receiver), isolate()), name, code);
+  PatchCache(CurrentTypeOf(receiver, isolate()), name, code);
   TRACE_IC("StoreIC", name);
 }