Improved function entry hook coverage

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 12270 matching lines @@
 
 static void entry_hook(uintptr_t function,
                        uintptr_t return_addr_location) {
   i::Code* code = i::Code::GetCodeFromTargetAddress(
       reinterpret_cast<i::Address>(function));
   CHECK(code != NULL);
 
   if (bar_ptr != NULL && code == (*bar_ptr)->code())
     ++bar_entry_count;
 
-  if (foo_ptr != NULL && code == (*foo_ptr)->code())
+  if (foo_ptr != NULL && code == (*foo_ptr)->code()) {
     ++foo_entry_count;
 
-  // Let's check whether bar is the caller.
-  if (bar_ptr != NULL) {
-    const v8::internal::byte* caller =
-        *reinterpret_cast<v8::internal::byte**>(return_addr_location);
+    // Count the bar->foo calls.
+    if (bar_ptr != NULL) {
+      const v8::internal::byte* caller =
+          *reinterpret_cast<v8::internal::byte**>(return_addr_location);
 
-    if ((*bar_ptr)->code()->instruction_start() <= caller &&
-        (*bar_ptr)->code()->instruction_end() > caller) {
-      ++bar_caller_count;
+      if ((*bar_ptr)->code()->instruction_start() <= caller &&
+          (*bar_ptr)->code()->instruction_end() > caller) {
+        ++bar_caller_count;
+      }
     }
   }
 }
 
 
-static void RunLoopInNewEnv() {
+static void RunLoopInNewEnv(v8::Isolate* isolate) {
   bar_ptr = NULL;
   foo_ptr = NULL;
 
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope outer(isolate);
   v8::Local<Context> env = Context::New(isolate);
   env->Enter();
 
   const char* script =
       "function bar() {"
       "  var sum = 0;"
       "  for (i = 0; i < 100; ++i)"
       "    sum = foo(i);"
       "  return sum;"
@@ skipping 31 matching lines @@
   // FunctionEntryHook does not work well with experimental natives.
   // Experimental natives are compiled during snapshot deserialization.
   // This test breaks because InstallGetter (function from snapshot that
   // only gets called from experimental natives) is compiled with entry hooks.
   i::FLAG_harmony_typed_arrays = false;
   i::FLAG_harmony_array_buffer = false;
 
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_use_inlining = false;
 
-  // Test setting and resetting the entry hook.
+  // Test setting and resetting the entry hook on the current isolate.
   // Nulling it should always succeed.
   CHECK(v8::V8::SetFunctionEntryHook(NULL));
 
   CHECK(v8::V8::SetFunctionEntryHook(entry_hook));
   // Setting a hook while one's active should fail.
   CHECK_EQ(false, v8::V8::SetFunctionEntryHook(entry_hook));
 
   CHECK(v8::V8::SetFunctionEntryHook(NULL));
 
-  // Reset the entry count to zero and set the entry hook.
-  bar_entry_count = 0;
-  bar_caller_count = 0;
-  foo_entry_count = 0;
-  CHECK(v8::V8::SetFunctionEntryHook(entry_hook));
-  RunLoopInNewEnv();
+  v8::Isolate* isolate = v8::Isolate::New();
+  {
+    v8::Isolate::Scope scope(isolate);
 
-  CHECK_EQ(2, bar_entry_count);
-  CHECK_EQ(200, bar_caller_count);
-  CHECK_EQ(200, foo_entry_count);
+    // Reset the entry count to zero and set the entry hook.
+    bar_entry_count = 0;
+    bar_caller_count = 0;
+    foo_entry_count = 0;
+    CHECK(v8::V8::SetFunctionEntryHook(entry_hook));
+    RunLoopInNewEnv(isolate);
 
-  // Clear the entry hook and count.
-  bar_entry_count = 0;
-  bar_caller_count = 0;
-  foo_entry_count = 0;
-  v8::V8::SetFunctionEntryHook(NULL);
+    CHECK_EQ(2, bar_entry_count);
+    CHECK_EQ(200, bar_caller_count);
+    CHECK_EQ(200, foo_entry_count);
 
-  // Clear the compilation cache to make sure we don't reuse the
-  // functions from the previous invocation.
-  v8::internal::Isolate::Current()->compilation_cache()->Clear();
+    // Clear the entry hook and count.
+    bar_entry_count = 0;
+    bar_caller_count = 0;
+    foo_entry_count = 0;
+    v8::V8::SetFunctionEntryHook(NULL);
 
-  // Verify that entry hooking is now disabled.
-  RunLoopInNewEnv();
-  CHECK_EQ(0u, bar_entry_count);
-  CHECK_EQ(0u, bar_caller_count);
-  CHECK_EQ(0u, foo_entry_count);
+    // Clear the compilation cache to make sure we don't reuse the
+    // functions from the previous invocation.
+    v8::internal::Isolate::Current()->compilation_cache()->Clear();
+
+    // Verify that entry hooking is now disabled.
+    RunLoopInNewEnv(isolate);
+    CHECK_EQ(0u, bar_entry_count);
+    CHECK_EQ(0u, bar_caller_count);
+    CHECK_EQ(0u, foo_entry_count);
+  }
+  isolate->Dispose();
 }
 
 
 static i::HashMap* code_map = NULL;
 static i::HashMap* jitcode_line_info = NULL;
 static int saw_bar = 0;
 static int move_events = 0;
 
 
 static bool FunctionNameIs(const char* expected,
@@ skipping 6952 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32