[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 1034 matching lines @@
         if (accessors->IsAccessorPair()) {
           if (!holder->HasFastProperties()) break;
           // 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()) {
+            if (FLAG_runtime_call_stats) break;
             int index = lookup->GetAccessorIndex();
             return compiler.CompileLoadCallback(lookup->name(),
                                                 call_optimization, index);
           }
           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 (FLAG_runtime_call_stats) break;
           if (receiver_is_holder) {
             int index = lookup->GetAccessorIndex();
             LoadApiGetterStub stub(isolate(), true, index);
             return stub.GetCode();
           }
           NamedLoadHandlerCompiler compiler(isolate(), map, holder,
                                             cache_holder);
           return compiler.CompileLoadCallback(lookup->name(), info);
         }
       }
@@ skipping 462 matching lines @@
           TRACE_GENERIC_IC(isolate(), "StoreIC",
                            "special data property in prototype chain");
           break;
         }
         if (!AccessorInfo::IsCompatibleReceiverMap(isolate(), info,
                                                    receiver_map())) {
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver type");
           break;
         }
         NamedStoreHandlerCompiler compiler(isolate(), receiver_map(), holder);
+        if (FLAG_runtime_call_stats) break;
         return compiler.CompileStoreCallback(receiver, lookup->name(), info,
                                              language_mode());
       } 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)) {
+            if (FLAG_runtime_call_stats) break;
             return compiler.CompileStoreCallback(receiver, lookup->name(),
                                                  call_optimization,
                                                  lookup->GetAccessorIndex());
           }
           TRACE_GENERIC_IC(isolate(), "StoreIC", "incompatible receiver");
           break;
         }
         int expected_arguments = JSFunction::cast(*setter)
                                      ->shared()
                                      ->internal_formal_parameter_count();
@@ skipping 1166 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