[counters] Annotate v8 with more runtime call counters.

src/ic/ic.cc

 // Copyright 2012 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 "src/ic/ic.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/api-arguments.h"
 #include "src/arguments.h"
@@ skipping 1049 matching lines @@
           // When debugging we need to go the slow path to flood the accessor.
           if (GetSharedFunctionInfo()->HasDebugInfo()) break;
           Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
                                 isolate());
           CallOptimization call_optimization(getter);
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
           if (call_optimization.is_simple_api_call()) {
             TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
             int index = lookup->GetAccessorIndex();
-            return compiler.CompileLoadCallback(lookup->name(),
-                                                call_optimization, index);
+            Handle<Code> code = compiler.CompileLoadCallback(
+                lookup->name(), call_optimization, index);
+            if (FLAG_runtime_call_stats) return slow_stub();
+            return code;
           }
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadViaGetter);
           int expected_arguments = Handle<JSFunction>::cast(getter)
                                        ->shared()
                                        ->internal_formal_parameter_count();
           return compiler.CompileLoadViaGetter(
               lookup->name(), lookup->GetAccessorIndex(), expected_arguments);
         } else if (accessors->IsAccessorInfo()) {
           Handle<AccessorInfo> info = Handle<AccessorInfo>::cast(accessors);
           if (v8::ToCData<Address>(info->getter()) == nullptr) break;
           if (!AccessorInfo::IsCompatibleReceiverMap(isolate(), info, map)) {
             // This case should be already handled in LoadIC::UpdateCaches.
             UNREACHABLE();
             break;
           }
           if (!holder->HasFastProperties()) break;
           if (receiver_is_holder) {
             TRACE_HANDLER_STATS(isolate(), LoadIC_LoadApiGetterStub);
             int index = lookup->GetAccessorIndex();
             LoadApiGetterStub stub(isolate(), true, index);
             return stub.GetCode();
           }
           if (info->is_sloppy() && !receiver->IsJSReceiver()) break;
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadCallback);
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
-          return compiler.CompileLoadCallback(lookup->name(), info);
+          Handle<Code> code =
+              compiler.CompileLoadCallback(lookup->name(), info);
+          if (FLAG_runtime_call_stats) return slow_stub();
+          return code;
         }
       }
       break;
     }
 
     case LookupIterator::DATA: {
       if (lookup->is_dictionary_holder()) {
         if (kind() != Code::LOAD_IC) break;
         if (holder->IsJSGlobalObject()) {
           TRACE_HANDLER_STATS(isolate(), LoadIC_LoadGlobal);
@@ skipping 467 matching lines @@
           break;
         }
         if (!AccessorInfo::IsCompatibleReceiverMap(isolate(), info,
                                                    receiver_map())) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver type");
           break;
         }
         if (info->is_sloppy() && !receiver->IsJSReceiver()) break;
         TRACE_HANDLER_STATS(isolate(), StoreIC_StoreCallback);
         NamedStoreHandlerCompiler compiler(isolate(), receiver_map(), holder);
-        return compiler.CompileStoreCallback(receiver, lookup->name(), info,
-                                             language_mode());
+        Handle<Code> code = compiler.CompileStoreCallback(
+            receiver, lookup->name(), info, language_mode());
+        if (FLAG_runtime_call_stats) return slow_stub();
+        return code;
       } else if (accessors->IsAccessorPair()) {
         Handle<Object> setter(Handle<AccessorPair>::cast(accessors)->setter(),
                               isolate());
         if (!setter->IsJSFunction() && !setter->IsFunctionTemplateInfo()) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "setter not a function");
           break;
         }
         CallOptimization call_optimization(setter);
         NamedStoreHandlerCompiler compiler(isolate(), receiver_map(), holder);
         if (call_optimization.is_simple_api_call()) {
           if (call_optimization.IsCompatibleReceiver(receiver, holder)) {
             TRACE_HANDLER_STATS(isolate(), StoreIC_StoreCallback);
-            return compiler.CompileStoreCallback(receiver, lookup->name(),
-                                                 call_optimization,
-                                                 lookup->GetAccessorIndex());
+            Handle<Code> code = compiler.CompileStoreCallback(
+                receiver, lookup->name(), call_optimization,
+                lookup->GetAccessorIndex());
+            if (FLAG_runtime_call_stats) return slow_stub();
+            return code;
           }
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver");
           break;
         }
         TRACE_HANDLER_STATS(isolate(), StoreIC_StoreViaSetter);
         int expected_arguments = JSFunction::cast(*setter)
                                      ->shared()
                                      ->internal_formal_parameter_count();
         return compiler.CompileStoreViaSetter(receiver, lookup->name(),
                                               lookup->GetAccessorIndex(),
@@ skipping 1170 matching lines @@
     KeyedLoadICNexus nexus(vector, vector_slot);
     KeyedLoadIC ic(IC::EXTRA_CALL_FRAME, isolate, &nexus);
     ic.UpdateState(receiver, key);
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, ic.Load(receiver, key));
   }
 
   return *result;
 }
 }  // namespace internal
 }  // namespace v8