Notify CPU profiler when calling native getters

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 786 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::Object> global = env->Global();
   global->Set(v8_str("pi"), v8_num(3.1415926));
   Local<Value> pi = global->Get(v8_str("pi"));
   CHECK_EQ(3.1415926, pi->NumberValue());
 }
 
 
 template<typename T>
-static void CheckReturnValue(const T& t) {
+static void CheckReturnValue(const T& t, i::Address callback) {
   v8::ReturnValue<v8::Value> rv = t.GetReturnValue();
   i::Object** o = *reinterpret_cast<i::Object***>(&rv);
   CHECK_EQ(v8::Isolate::GetCurrent(), t.GetIsolate());
   CHECK_EQ(t.GetIsolate(), rv.GetIsolate());
   CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
   // Verify reset
   bool is_runtime = (*o)->IsTheHole();
   rv.Set(true);
   CHECK(!(*o)->IsTheHole() && !(*o)->IsUndefined());
   rv.Set(v8::Handle<v8::Object>());
   CHECK((*o)->IsTheHole() || (*o)->IsUndefined());
   CHECK_EQ(is_runtime, (*o)->IsTheHole());
+
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(t.GetIsolate());
+  // If CPU profiler is active check that when API callback is invoked
+  // VMState is set to EXTERNAL.
+  if (isolate->cpu_profiler()->is_profiling()) {
+    CHECK_EQ(i::EXTERNAL, isolate->current_vm_state());
+    CHECK(isolate->external_callback());
+    CHECK_EQ(callback, isolate->external_callback());
+  }
 }
 
-static v8::Handle<Value> handle_call(const v8::Arguments& args) {
+static v8::Handle<Value> handle_call_impl(
+    const v8::Arguments& args,
+    i::Address callback) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, callback);
   args.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(102);
 }
 
-static v8::Handle<Value> handle_call_2(const v8::Arguments& args) {
-  return handle_call(args);
+static v8::Handle<Value> handle_call(const v8::Arguments& args) {
+  return handle_call_impl(args, FUNCTION_ADDR(handle_call));
 }
 
-static v8::Handle<Value> handle_call_indirect(const v8::Arguments& args) {
+static v8::Handle<Value> handle_call_2(const v8::Arguments& args) {
+  return handle_call_impl(args, FUNCTION_ADDR(handle_call_2));
+}
+
+static v8::Handle<Value> handle_call_indirect_impl(const v8::Arguments& args,
+                                                   i::Address callback) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, callback);
   args.GetReturnValue().Set(v8_str("bad value"));
   args.GetReturnValue().Set(v8_num(102));
   return v8::Handle<Value>();
 }
 
-static v8::Handle<Value> handle_call_indirect_2(const v8::Arguments& args) {
-  return handle_call_indirect(args);
+static v8::Handle<Value> handle_call_indirect(const v8::Arguments& args) {
+  return handle_call_indirect_impl(args, FUNCTION_ADDR(handle_call_indirect));
 }
 
-static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) {
+static v8::Handle<Value> handle_call_indirect_2(const v8::Arguments& args) {
+  return handle_call_indirect_impl(args, FUNCTION_ADDR(handle_call_indirect_2));
+}
+
+static void handle_callback_impl(const v8::FunctionCallbackInfo<Value>& info,
+                                 i::Address callback) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, callback);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(102));
 }
 
+static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) {
+  return handle_callback_impl(info, FUNCTION_ADDR(handle_callback));
+}
+
 static void handle_callback_2(const v8::FunctionCallbackInfo<Value>& info) {
-  return handle_callback(info);
+  return handle_callback_impl(info, FUNCTION_ADDR(handle_callback_2));
 }
 
 static v8::Handle<Value> construct_call(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(construct_call));
   args.This()->Set(v8_str("x"), v8_num(1));
   args.This()->Set(v8_str("y"), v8_num(2));
   args.GetReturnValue().Set(v8_str("bad value"));
   return args.This();
 }
 
 static v8::Handle<Value> construct_call_indirect(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(construct_call_indirect));
   args.This()->Set(v8_str("x"), v8_num(1));
   args.This()->Set(v8_str("y"), v8_num(2));
   args.GetReturnValue().Set(v8_str("bad value"));
   args.GetReturnValue().Set(args.This());
   return v8::Handle<Value>();
 }
 
 static void construct_callback(
     const v8::FunctionCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(construct_callback));
   info.This()->Set(v8_str("x"), v8_num(1));
   info.This()->Set(v8_str("y"), v8_num(2));
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(info.This());
 }
 
 
 static v8::Handle<Value> Return239(
     Local<String> name, const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(Return239));
   info.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(239);
 }
 
 static v8::Handle<Value> Return239Indirect(
     Local<String> name, const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(Return239Indirect));
   Handle<Value> value = v8_num(239);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(value);
   return v8::Handle<Value>();
 }
 
 static void Return239Callback(
     Local<String> name, const v8::PropertyCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(Return239Callback));
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(239));
 }
 
 
 template<typename Handler>
 static void TestFunctionTemplateInitializer(Handler handler,
                                             Handler handler_2) {
-  // Test constructor calls.
-  {
-    LocalContext env;
-    v8::HandleScope scope(env->GetIsolate());
-    Local<v8::FunctionTemplate> fun_templ =
-        v8::FunctionTemplate::New(handler);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
-    Local<Script> script = v8_compile("obj()");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(102, script->Run()->Int32Value());
+  for (int i = 0; i < 2; i++) {
+    bool is_profiling = (i > 0);
+    // Test constructor calls.
+    {
+      LocalContext env;
+      v8::HandleScope scope(env->GetIsolate());
+
+      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
+      v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
+      if (is_profiling) {
+        cpu_profiler->StartCpuProfiling(profile_name);
+      }
+
+      Local<v8::FunctionTemplate> fun_templ =
+          v8::FunctionTemplate::New(handler);
+      Local<Function> fun = fun_templ->GetFunction();
+      env->Global()->Set(v8_str("obj"), fun);
+      Local<Script> script = v8_compile("obj()");
+      for (int i = 0; i < 30; i++) {
+        CHECK_EQ(102, script->Run()->Int32Value());
+      }
+
+      if (is_profiling) {
+        cpu_profiler->StopCpuProfiling(profile_name);
+      }
     }
-  }
-  // Use SetCallHandler to initialize a function template, should work like the
-  // previous one.
-  {
-    LocalContext env;
-    v8::HandleScope scope(env->GetIsolate());
-    Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
-    fun_templ->SetCallHandler(handler_2);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
-    Local<Script> script = v8_compile("obj()");
-    for (int i = 0; i < 30; i++) {
-      CHECK_EQ(102, script->Run()->Int32Value());
+    // Use SetCallHandler to initialize a function template, should work like
+    // the previous one.
+    {
+      LocalContext env;
+      v8::HandleScope scope(env->GetIsolate());
+
+      v8::Local<v8::String> profile_name = v8::String::New("my_profile2");
+      v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
+      if (is_profiling) {
+        cpu_profiler->StartCpuProfiling(profile_name);
+      }
+
+      Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
+      fun_templ->SetCallHandler(handler_2);
+      Local<Function> fun = fun_templ->GetFunction();
+      env->Global()->Set(v8_str("obj"), fun);
+      Local<Script> script = v8_compile("obj()");
+      for (int i = 0; i < 30; i++) {
+        CHECK_EQ(102, script->Run()->Int32Value());
+      }
+
+      if (is_profiling) {
+        cpu_profiler->DeleteAllCpuProfiles();
+      }
     }
   }
 }
 
 
 template<typename Constructor, typename Accessor>
 static void TestFunctionTemplateAccessor(Constructor constructor,
                                          Accessor accessor) {
-  LocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
-  Local<v8::FunctionTemplate> fun_templ =
-      v8::FunctionTemplate::New(constructor);
-  fun_templ->SetClassName(v8_str("funky"));
-  fun_templ->InstanceTemplate()->SetAccessor(v8_str("m"), accessor);
-  Local<Function> fun = fun_templ->GetFunction();
-  env->Global()->Set(v8_str("obj"), fun);
-  Local<Value> result = v8_compile("(new obj()).toString()")->Run();
-  CHECK_EQ(v8_str("[object funky]"), result);
-  CompileRun("var obj_instance = new obj();");
-  Local<Script> script;
-  script = v8_compile("obj_instance.x");
-  for (int i = 0; i < 30; i++) {
-    CHECK_EQ(1, script->Run()->Int32Value());
-  }
-  script = v8_compile("obj_instance.m");
-  for (int i = 0; i < 30; i++) {
-    CHECK_EQ(239, script->Run()->Int32Value());
+  for (int i = 0; i < 2; i++) {
+    bool is_profiling = (i > 0);
+    LocalContext env;
+    v8::HandleScope scope(env->GetIsolate());
+
+    v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
+    if (is_profiling) {
+      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
+      cpu_profiler->StartCpuProfiling(profile_name);
+    }
+
+    Local<v8::FunctionTemplate> fun_templ =
+        v8::FunctionTemplate::New(constructor);
+    fun_templ->SetClassName(v8_str("funky"));
+    fun_templ->InstanceTemplate()->SetAccessor(v8_str("m"), accessor);
+    Local<Function> fun = fun_templ->GetFunction();
+    env->Global()->Set(v8_str("obj"), fun);
+    Local<Value> result = v8_compile("(new obj()).toString()")->Run();
+    CHECK_EQ(v8_str("[object funky]"), result);
+    CompileRun("var obj_instance = new obj();");
+    Local<Script> script;
+    script = v8_compile("obj_instance.x");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(1, script->Run()->Int32Value());
+    }
+    script = v8_compile("obj_instance.m");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(239, script->Run()->Int32Value());
+    }
+
+    if (is_profiling) {
+      cpu_profiler->DeleteAllCpuProfiles();
+    }
   }
 }
 
 
 THREADED_TEST(FunctionTemplate) {
   TestFunctionTemplateInitializer(handle_call, handle_call_2);
   TestFunctionTemplateInitializer(handle_call_indirect, handle_call_indirect_2);
   TestFunctionTemplateInitializer(handle_callback, handle_callback_2);
 
   TestFunctionTemplateAccessor(construct_call, Return239);
   TestFunctionTemplateAccessor(construct_call_indirect, Return239Indirect);
   TestFunctionTemplateAccessor(construct_callback, Return239Callback);
 }
 
 
 static v8::Handle<v8::Value> SimpleDirectCallback(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(SimpleDirectCallback));
   args.GetReturnValue().Set(v8_str("bad value"));
   return v8_num(51423 + args.Length());
 }
 
 static v8::Handle<v8::Value> SimpleIndirectCallback(const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(SimpleIndirectCallback));
   args.GetReturnValue().Set(v8_num(51423 + args.Length()));
   return v8::Handle<v8::Value>();
 }
 
 static void SimpleCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(SimpleCallback));
   info.GetReturnValue().Set(v8_num(51423 + info.Length()));
 }
 
 
 template<typename Callback>
 static void TestSimpleCallback(Callback callback) {
-  LocalContext env;
-  v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
-  object_template->Set("callback", v8::FunctionTemplate::New(callback));
-  v8::Local<v8::Object> object = object_template->NewInstance();
-  (*env)->Global()->Set(v8_str("callback_object"), object);
-  v8::Handle<v8::Script> script;
-  script = v8_compile("callback_object.callback(17)");
-  for (int i = 0; i < 30; i++) {
-    CHECK_EQ(51424, script->Run()->Int32Value());
-  }
-  script = v8_compile("callback_object.callback(17, 24)");
-  for (int i = 0; i < 30; i++) {
-    CHECK_EQ(51425, script->Run()->Int32Value());
+  for (int i = 0; i < 2; i++) {
+    bool is_profiling = i;
+    LocalContext env;
+    v8::HandleScope scope(env->GetIsolate());
+
+    v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
+    if (is_profiling) {
+      v8::Local<v8::String> profile_name = v8::String::New("my_profile1");
+      cpu_profiler->StartCpuProfiling(profile_name);
+    }
+
+    v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
+    object_template->Set("callback", v8::FunctionTemplate::New(callback));
+    v8::Local<v8::Object> object = object_template->NewInstance();
+    (*env)->Global()->Set(v8_str("callback_object"), object);
+    v8::Handle<v8::Script> script;
+    script = v8_compile("callback_object.callback(17)");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(51424, script->Run()->Int32Value());
+    }
+    script = v8_compile("callback_object.callback(17, 24)");
+    for (int i = 0; i < 30; i++) {
+      CHECK_EQ(51425, script->Run()->Int32Value());
+    }
+
+    if (is_profiling) {
+      cpu_profiler->DeleteAllCpuProfiles();
+    }
   }
 }
 
 
 THREADED_TEST(SimpleCallback) {
   TestSimpleCallback(SimpleDirectCallback);
   TestSimpleCallback(SimpleIndirectCallback);
   TestSimpleCallback(SimpleCallback);
 }
 
 
 template<typename T>
 void FastReturnValueCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
 
 // constant return values
 static int32_t fast_return_value_int32 = 471;
 static uint32_t fast_return_value_uint32 = 571;
 static const double kFastReturnValueDouble = 2.7;
 // variable return values
 static bool fast_return_value_bool = false;
 enum ReturnValueOddball {
   kNullReturnValue,
   kUndefinedReturnValue,
   kEmptyStringReturnValue
 };
 static ReturnValueOddball fast_return_value_void;
 static bool fast_return_value_object_is_empty = false;
 
+// Helper function to avoid compiler error: insufficient contextual information
+// to determine type when applying FUNCTION_ADDR to a template function.
+static i::Address address_of(v8::FunctionCallback callback) {
+  return FUNCTION_ADDR(callback);
+}
+
 template<>
 void FastReturnValueCallback<int32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, address_of(FastReturnValueCallback<int32_t>));
   info.GetReturnValue().Set(fast_return_value_int32);
 }
 
 template<>
 void FastReturnValueCallback<uint32_t>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, address_of(FastReturnValueCallback<uint32_t>));
   info.GetReturnValue().Set(fast_return_value_uint32);
 }
 
 template<>
 void FastReturnValueCallback<double>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, address_of(FastReturnValueCallback<double>));
   info.GetReturnValue().Set(kFastReturnValueDouble);
 }
 
 template<>
 void FastReturnValueCallback<bool>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, address_of(FastReturnValueCallback<bool>));
   info.GetReturnValue().Set(fast_return_value_bool);
 }
 
 template<>
 void FastReturnValueCallback<void>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, address_of(FastReturnValueCallback<void>));
   switch (fast_return_value_void) {
     case kNullReturnValue:
       info.GetReturnValue().SetNull();
       break;
     case kUndefinedReturnValue:
       info.GetReturnValue().SetUndefined();
       break;
     case kEmptyStringReturnValue:
       info.GetReturnValue().SetEmptyString();
       break;
@@ skipping 956 matching lines @@
   Local<Script> script = v8_compile("obj[900]");
   CHECK_EQ(script->Run()->Int32Value(), 900);
 }
 
 
 v8::Handle<v8::Object> bottom;
 
 static void CheckThisIndexedPropertyHandler(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyHandler));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 static void CheckThisNamedPropertyHandler(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyHandler));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 void CheckThisIndexedPropertySetter(
     uint32_t index,
     Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertySetter));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertySetter(
     Local<String> property,
     Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertySetter));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 void CheckThisIndexedPropertyQuery(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Integer>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyQuery));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyQuery(
     Local<String> property,
     const v8::PropertyCallbackInfo<v8::Integer>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyQuery));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisIndexedPropertyDeleter(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyDeleter));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyDeleter(
     Local<String> property,
     const v8::PropertyCallbackInfo<v8::Boolean>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyDeleter));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisIndexedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisIndexedPropertyEnumerator));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 void CheckThisNamedPropertyEnumerator(
     const v8::PropertyCallbackInfo<v8::Array>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(CheckThisNamedPropertyEnumerator));
   ApiTestFuzzer::Fuzz();
   CHECK(info.This()->Equals(bottom));
 }
 
 
 THREADED_TEST(PropertyHandlerInPrototype) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Set up a prototype chain with three interceptors.
@@ skipping 8485 matching lines @@
     "  result"
     "} catch(e) {"
     "  e"
     "};");
   CHECK_EQ(239 * 10, value->Int32Value());
 }
 
 static v8::Handle<Value> InterceptorCallICFastApi(Local<String> name,
                                                   const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(InterceptorCallICFastApi));
   int* call_count =
       reinterpret_cast<int*>(v8::External::Cast(*info.Data())->Value());
   ++(*call_count);
   if ((*call_count) % 20 == 0) {
     HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
   }
   return v8::Handle<Value>();
 }
 
 static v8::Handle<Value> FastApiCallback_TrivialSignature(
     const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_TrivialSignature));
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK_EQ(args.This(), args.Holder());
   CHECK(args.Data()->Equals(v8_str("method_data")));
   return v8::Integer::New(args[0]->Int32Value() + 1);
 }
 
 static v8::Handle<Value> FastApiCallback_SimpleSignature(
     const v8::Arguments& args) {
   ApiTestFuzzer::Fuzz();
-  CheckReturnValue(args);
+  CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_SimpleSignature));
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK_EQ(args.This()->GetPrototype(), args.Holder());
   CHECK(args.Data()->Equals(v8_str("method_data")));
   // Note, we're using HasRealNamedProperty instead of Has to avoid
   // invoking the interceptor again.
   CHECK(args.Holder()->HasRealNamedProperty(v8_str("foo")));
   return v8::Integer::New(args[0]->Int32Value() + 1);
 }
 
@@ skipping 67 matching lines @@
 static Handle<Value> DoDirectGetter() {
   if (++p_getter_count % 3 == 0) {
     HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
     GenerateSomeGarbage();
   }
   return v8_str("Direct Getter Result");
 }
 
 static v8::Handle<v8::Value> DirectGetter(Local<String> name,
                                   const v8::AccessorInfo& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(DirectGetter));
   info.GetReturnValue().Set(v8_str("Garbage"));
   return DoDirectGetter();
 }
 
 static v8::Handle<v8::Value> DirectGetterIndirect(
     Local<String> name,
     const v8::AccessorInfo& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(DirectGetterIndirect));
   info.GetReturnValue().Set(DoDirectGetter());
   return v8::Handle<v8::Value>();
 }
 
 static void DirectGetterCallback(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  CheckReturnValue(info);
+  CheckReturnValue(info, FUNCTION_ADDR(DirectGetterCallback));
   info.GetReturnValue().Set(DoDirectGetter());
 }
 
 
 template<typename Accessor>
 static void LoadICFastApi_DirectCall_GCMoveStub(Accessor accessor) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> obj = v8::ObjectTemplate::New();
   obj->SetAccessor(v8_str("p1"), accessor);
@@ skipping 8591 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32