Implement ICs for constructor calls.

src/ic.cc

Index: src/ic.cc
diff --git a/src/ic.cc b/src/ic.cc
index 2c6d55b93fce474d6c9452de3705604f09fcc05a..fa4485762d3ba8062bfdb4661e18cf2621e9bb14 100644
--- a/src/ic.cc
+++ b/src/ic.cc
@@ -58,6 +58,13 @@ static char TransitionMarkFromState(IC::State state) {
   return 0;
 }
 
+static const char* NameForCallIC(Code::Kind kind,
+                                 Code::ExtraICState extra_ic_state) {
+  return CallICBase::ConstructCall::decode(extra_ic_state)
+      ? (kind == Code::CALL_IC ? "ConstructIC" : "KeyedConstructIC")
+      : (kind == Code::CALL_IC ? "CallIC" : "KeyedCallIC");
+}
+
 void IC::TraceIC(const char* type,
                  Handle<Object> name,
                  State old_state,
@@ -302,11 +309,9 @@ void IC::Clear(Address address) {
 
   switch (target->kind()) {
     case Code::LOAD_IC: return LoadIC::Clear(address, target);
-    case Code::KEYED_LOAD_IC:
-      return KeyedLoadIC::Clear(address, target);
+    case Code::KEYED_LOAD_IC: return KeyedLoadIC::Clear(address, target);
     case Code::STORE_IC: return StoreIC::Clear(address, target);
-    case Code::KEYED_STORE_IC:
-      return KeyedStoreIC::Clear(address, target);
+    case Code::KEYED_STORE_IC: return KeyedStoreIC::Clear(address, target);
     case Code::CALL_IC: return CallIC::Clear(address, target);
     case Code::KEYED_CALL_IC:  return KeyedCallIC::Clear(address, target);
     case Code::UNARY_OP_IC:
@@ -323,12 +328,15 @@ void IC::Clear(Address address) {
 
 void CallICBase::Clear(Address address, Code* target) {
   bool contextual = CallICBase::Contextual::decode(target->extra_ic_state());
+  bool construct = CallICBase::ConstructCall::decode(target->extra_ic_state());
+  RelocInfo::Mode mode = construct ? RelocInfo::CONSTRUCT_CALL :
+      (contextual ? RelocInfo::CODE_TARGET_CONTEXT : RelocInfo::CODE_TARGET);
   State state = target->ic_state();
   if (state == UNINITIALIZED) return;
   Code* code =
       Isolate::Current()->stub_cache()->FindCallInitialize(
           target->arguments_count(),
-          contextual ? RelocInfo::CODE_TARGET_CONTEXT : RelocInfo::CODE_TARGET,
+          mode,
           target->kind());
   SetTargetAtAddress(address, code);
 }
@@ -703,17 +711,17 @@ void CallICBase::UpdateCaches(LookupResult* lookup,
   }
 
   if (had_proto_failure) state = MONOMORPHIC_PROTOTYPE_FAILURE;
-  TRACE_IC(kind_ == Code::CALL_IC ? "CallIC" : "KeyedCallIC",
-           name, state, target());
+  TRACE_IC(NameForCallIC(kind_, extra_ic_state), name, state, target());
 }
 
 
 MaybeObject* KeyedCallIC::LoadFunction(State state,
+                                       Code::ExtraICState extra_ic_state,
                                        Handle<Object> object,
                                        Handle<Object> key) {
   if (key->IsSymbol()) {
     return CallICBase::LoadFunction(state,
-                                    Code::kNoExtraICState,
+                                    extra_ic_state,
                                     object,
                                     Handle<String>::cast(key));
   }
@@ -729,14 +737,14 @@ MaybeObject* KeyedCallIC::LoadFunction(State state,
     if (object->IsJSObject() &&
         Handle<JSObject>::cast(object)->elements()->map() == *map) {
       Handle<Code> code = isolate()->stub_cache()->ComputeCallArguments(
-          argc, Code::KEYED_CALL_IC);
+          argc, Code::KEYED_CALL_IC, extra_ic_state);
       set_target(*code);
-      TRACE_IC("KeyedCallIC", key, state, target());
+      TRACE_IC(NameForCallIC(kind_, extra_ic_state), key, state, target());
     } else if (!object->IsAccessCheckNeeded()) {
       Handle<Code> code = isolate()->stub_cache()->ComputeCallMegamorphic(
-          argc, Code::KEYED_CALL_IC, Code::kNoExtraICState);
+          argc, Code::KEYED_CALL_IC, extra_ic_state);
       set_target(*code);
-      TRACE_IC("KeyedCallIC", key, state, target());
+      TRACE_IC(NameForCallIC(kind_, extra_ic_state), key, state, target());
     }
   }
 
@@ -1812,8 +1820,11 @@ RUNTIME_FUNCTION(MaybeObject*, KeyedCallIC_Miss) {
   ASSERT(args.length() == 2);
   KeyedCallIC ic(isolate);
   IC::State state = IC::StateFrom(ic.target(), args[0], args[1]);
-  MaybeObject* maybe_result =
-      ic.LoadFunction(state, args.at<Object>(0), args.at<Object>(1));
+  Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
+  MaybeObject* maybe_result = ic.LoadFunction(state,
+                                              extra_ic_state,
+                                              args.at<Object>(0),
+                                              args.at<Object>(1));
   // Result could be a function or a failure.
   JSFunction* raw_function = NULL;
   if (!maybe_result->To(&raw_function)) return maybe_result;