Do not expose all timer events to the API callback.

src/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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/codegen.h"
@@ skipping 1936 matching lines @@
 
 #undef TRACE_IC
 
 
 // ----------------------------------------------------------------------------
 // Static IC stub generators.
 //
 
 // Used from ic-<arch>.cc.
 RUNTIME_FUNCTION(CallIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
   CallIC ic(isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<Object> function = args.at<Object>(1);
   Handle<FixedArray> vector = args.at<FixedArray>(2);
   Handle<Smi> slot = args.at<Smi>(3);
   ic.HandleMiss(receiver, function, vector, slot);
   return *function;
 }
 
 
 RUNTIME_FUNCTION(CallIC_Customization_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
   // A miss on a custom call ic always results in going megamorphic.
   CallIC ic(isolate);
   Handle<Object> function = args.at<Object>(1);
   Handle<FixedArray> vector = args.at<FixedArray>(2);
   Handle<Smi> slot = args.at<Smi>(3);
   ic.PatchMegamorphic(vector, slot);
   return *function;
 }
 
 
 // Used from ic-<arch>.cc.
 RUNTIME_FUNCTION(LoadIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   LoadIC ic(IC::NO_EXTRA_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<String> key = args.at<String>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, ic.Load(receiver, key));
   return *result;
 }
 
 
 // Used from ic-<arch>.cc
 RUNTIME_FUNCTION(KeyedLoadIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   KeyedLoadIC ic(IC::NO_EXTRA_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<Object> key = args.at<Object>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, ic.Load(receiver, key));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(KeyedLoadIC_MissFromStubFailure) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 2);
   KeyedLoadIC ic(IC::EXTRA_CALL_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<Object> key = args.at<Object>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, ic.Load(receiver, key));
   return *result;
 }
 
 
 // Used from ic-<arch>.cc.
 RUNTIME_FUNCTION(StoreIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   StoreIC ic(IC::NO_EXTRA_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<String> key = args.at<String>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate,
       result,
       ic.Store(receiver, key, args.at<Object>(2)));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(StoreIC_MissFromStubFailure) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   StoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<String> key = args.at<String>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate,
       result,
       ic.Store(receiver, key, args.at<Object>(2)));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(StoreIC_ArrayLength) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
 
   ASSERT(args.length() == 2);
   Handle<JSArray> receiver = args.at<JSArray>(0);
   Handle<Object> len = args.at<Object>(1);
 
   // The generated code should filter out non-Smis before we get here.
   ASSERT(len->IsSmi());
 
 #ifdef DEBUG
   // The length property has to be a writable callback property.
   LookupResult debug_lookup(isolate);
   receiver->LookupOwn(isolate->factory()->length_string(), &debug_lookup);
   ASSERT(debug_lookup.IsPropertyCallbacks() && !debug_lookup.IsReadOnly());
 #endif
 
   RETURN_FAILURE_ON_EXCEPTION(
       isolate, JSArray::SetElementsLength(receiver, len));
   return *len;
 }
 
 
 // Extend storage is called in a store inline cache when
 // it is necessary to extend the properties array of a
 // JSObject.
 RUNTIME_FUNCTION(SharedStoreIC_ExtendStorage) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope shs(isolate);
   ASSERT(args.length() == 3);
 
   // Convert the parameters
   Handle<JSObject> object = args.at<JSObject>(0);
   Handle<Map> transition = args.at<Map>(1);
   Handle<Object> value = args.at<Object>(2);
 
   // Check the object has run out out property space.
   ASSERT(object->HasFastProperties());
   ASSERT(object->map()->unused_property_fields() == 0);
 
   JSObject::MigrateToNewProperty(object, transition, value);
 
   // Return the stored value.
   return *value;
 }
 
 
 // Used from ic-<arch>.cc.
 RUNTIME_FUNCTION(KeyedStoreIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<Object> key = args.at<Object>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate,
       result,
       ic.Store(receiver, key, args.at<Object>(2)));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(KeyedStoreIC_MissFromStubFailure) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
   Handle<Object> receiver = args.at<Object>(0);
   Handle<Object> key = args.at<Object>(1);
   ic.UpdateState(receiver, key);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate,
       result,
@@ skipping 30 matching lines @@
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result,
       Runtime::SetObjectProperty(
           isolate, object, key, value, strict_mode));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 4);
   KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
   Handle<Object> value = args.at<Object>(0);
   Handle<Map> map = args.at<Map>(1);
   Handle<Object> key = args.at<Object>(2);
   Handle<Object> object = args.at<Object>(3);
   StrictMode strict_mode = ic.strict_mode();
   if (object->IsJSObject()) {
     JSObject::TransitionElementsKind(Handle<JSObject>::cast(object),
@@ skipping 484 matching lines @@
     PatchInlinedSmiCode(address(), ENABLE_INLINED_SMI_CHECK);
   } else if (old_state.UseInlinedSmiCode() && !state.UseInlinedSmiCode()) {
     PatchInlinedSmiCode(address(), DISABLE_INLINED_SMI_CHECK);
   }
 
   return result;
 }
 
 
 RUNTIME_FUNCTION(BinaryOpIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT_EQ(2, args.length());
   Handle<Object> left = args.at<Object>(BinaryOpICStub::kLeft);
   Handle<Object> right = args.at<Object>(BinaryOpICStub::kRight);
   BinaryOpIC ic(isolate);
   Handle<Object> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate,
       result,
       ic.Transition(Handle<AllocationSite>::null(), left, right));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT_EQ(3, args.length());
   Handle<AllocationSite> allocation_site = args.at<AllocationSite>(
       BinaryOpWithAllocationSiteStub::kAllocationSite);
   Handle<Object> left = args.at<Object>(
       BinaryOpWithAllocationSiteStub::kLeft);
   Handle<Object> right = args.at<Object>(
       BinaryOpWithAllocationSiteStub::kRight);
   BinaryOpIC ic(isolate);
   Handle<Object> result;
@@ skipping 213 matching lines @@
   if (previous_state == UNINITIALIZED) {
     PatchInlinedSmiCode(address(), ENABLE_INLINED_SMI_CHECK);
   }
 
   return *new_target;
 }
 
 
 // Used from ICCompareStub::GenerateMiss in code-stubs-<arch>.cc.
 RUNTIME_FUNCTION(CompareIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
   CompareIC ic(isolate, static_cast<Token::Value>(args.smi_at(2)));
   return ic.UpdateCaches(args.at<Object>(0), args.at<Object>(1));
 }
 
 
 void CompareNilIC::Clear(Address address,
                          Code* target,
                          ConstantPoolArray* constant_pool) {
@@ skipping 44 matching lines @@
     code = isolate()->stub_cache()->ComputeCompareNil(monomorphic_map, &stub);
   } else {
     code = stub.GetCode();
   }
   set_target(*code);
   return DoCompareNilSlow(isolate(), nil, object);
 }
 
 
 RUNTIME_FUNCTION(CompareNilIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   HandleScope scope(isolate);
   Handle<Object> object = args.at<Object>(0);
   CompareNilIC ic(isolate);
   return *ic.CompareNil(object);
 }
 
 
 RUNTIME_FUNCTION(Unreachable) {
   UNREACHABLE();
   CHECK(false);
@@ skipping 45 matching lines @@
 Handle<Object> ToBooleanIC::ToBoolean(Handle<Object> object) {
   ToBooleanStub stub(isolate(), target()->extra_ic_state());
   bool to_boolean_value = stub.UpdateStatus(object);
   Handle<Code> code = stub.GetCode();
   set_target(*code);
   return handle(Smi::FromInt(to_boolean_value ? 1 : 0), isolate());
 }
 
 
 RUNTIME_FUNCTION(ToBooleanIC_Miss) {
-  Logger::TimerEventScope timer(
-      isolate, Logger::TimerEventScope::v8_ic_miss);
+  TimerEventScope<TimerEventIcMiss> timer(isolate);
   ASSERT(args.length() == 1);
   HandleScope scope(isolate);
   Handle<Object> object = args.at<Object>(0);
   ToBooleanIC ic(isolate);
   return *ic.ToBoolean(object);
 }
 
 
 static const Address IC_utilities[] = {
 #define ADDR(name) FUNCTION_ADDR(name),
     IC_UTIL_LIST(ADDR)
     NULL
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal