Add a new API V8::SetJitCodeEventHandler to push code name and location to users such as profilers.

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 10924 matching lines @@
       reinterpret_cast<i::Address>(function));
   CHECK(code != NULL);
 
   if (bar_ptr != NULL && code == (*bar_ptr)->code())
     ++bar_count;
 
   if (foo_ptr != NULL && code == (*foo_ptr)->code())
     ++foo_count;
 
   // TODO(siggi): Verify return_addr_location.
+  //     This can be done by capturing JitCodeEvents, but requires an ordered
+  //     collection.
 }
 
 
 static void RunLoopInNewEnv() {
   bar_ptr = NULL;
   foo_ptr = NULL;
 
   v8::HandleScope outer;
   v8::Persistent<Context> env = Context::New();
   env->Enter();
@@ skipping 65 matching lines @@
   // functions from the previous invocation.
   v8::internal::Isolate::Current()->compilation_cache()->Clear();
 
   // Verify that entry hooking is now disabled.
   RunLoopInNewEnv();
   CHECK_EQ(0u, bar_count);
   CHECK_EQ(0u, foo_count);
 }
 
 
+static i::HashMap* code_map = NULL;
+static int saw_foo = 0;
+static int saw_bar = 0;
+static int move_events = 0;
+
+
+static void event_handler(const v8::JitCodeEvent* event) {
+  CHECK(event != NULL);
+  CHECK(code_map != NULL);
+
+  uint32_t hash = reinterpret_cast<uint32_t>(event->code_start);
+  switch(event->type) {
+    case v8::JitCodeEvent::CODE_ADDED: {
+        CHECK(event->code_start != NULL);
+        CHECK_NE(0, event->code_len);
+        CHECK(event->name != NULL);
+        i::HashMap::Entry* entry =
+            code_map->Lookup(event->code_start, hash, true);
+        entry->value = reinterpret_cast<void*>(event->code_len);
+
+        if (strcmp(event->name, "foo") == 0) {
+          ++saw_foo;
+        } else if (strcmp(event->name, "bar") == 0) {
+          ++saw_bar;
+        }
+        break;
+      }
+
+    case v8::JitCodeEvent::CODE_MOVED: {
+        ++move_events;
+
+        // We should never see code move that we haven't seen before.
+        i::HashMap::Entry* entry =
+            code_map->Lookup(event->code_start, hash, false);
+        CHECK(entry != NULL);
+        CHECK_EQ(reinterpret_cast<void*>(event->code_len),
+                 code_map->Remove(event->code_start, hash));
+        entry = code_map->Lookup(event->code_start, hash, true);
+        entry->value = reinterpret_cast<void*>(event->code_len);
+        break;
+      }
+
+      break;
+    case v8::JitCodeEvent::CODE_REMOVED:
+      // Object/code removal events are currently not dispatched from the GC.
+      CHECK(false);
+      break;
+    default:
+      // Impossible event.
+      CHECK(false);
+      break;
+  }
+}
+
+
+// Implemented in the test-alloc.cc test suite.
+void SimulateFullSpace(i::PagedSpace* space);
+
+
+static bool MatchPointers(void* key1, void* key2) {
+  return key1 == key2;
+}
+
+
+TEST(SetJitCodeEventHandler) {
+  // Run this test in a new isolate to make sure we don't
+  // have remnants of state from other code.
+  v8::Isolate* isolate = v8::Isolate::New();
+  isolate->Enter();
+
+  i::HashMap code(MatchPointers);
+  code_map = &code;
+  saw_foo = 0;
+  saw_bar = 0;
+  move_events = 0;
+
+
+  i::FLAG_stress_compaction = true;
+  v8::HandleScope scope;
+
+  const char* script =
+    "function bar() {"
+    "  var sum = 0;"
+    "  for (i = 0; i < 100; ++i)"
+    "    sum = foo(i);"
+    "  return sum;"
+    "}"
+    "function foo(i) { return i * i; };"
+    "foo(100);";
+
+  V8::SetJitCodeEventHandler(event_handler);
+
+  // Generate new code objects sparsely distributed across several
+  // different fragmented code-space pages.
+  const int kIterations = 10;
+  for (int i = 0; i < kIterations; ++i) {
+    LocalContext env;
+
+    i::AlwaysAllocateScope always_allocate;
+    v8_compile(script);
+    SimulateFullSpace(HEAP->code_space());
+
+    ISOLATE->compilation_cache()->Clear();
+  }
+
+  CHECK_EQ(kIterations, saw_bar);
+  CHECK_EQ(kIterations, saw_foo);
+  CHECK_NE(0, move_events);
+
+  code_map = NULL;
+  V8::SetJitCodeEventHandler(NULL);
+
+  isolate->Exit();
+  isolate->Dispose();
+}
+
+
 static int64_t cast(intptr_t x) { return static_cast<int64_t>(x); }
 
 
 THREADED_TEST(ExternalAllocatedMemory) {
   v8::HandleScope outer;
   v8::Persistent<Context> env(Context::New());
   CHECK(!env.IsEmpty());
   const intptr_t kSize = 1024*1024;
   CHECK_EQ(cast(v8::V8::AdjustAmountOfExternalAllocatedMemory(kSize)),
            cast(kSize));
@@ skipping 5977 matching lines @@
   v8::HandleScope scope;
   LocalContext context;
 
   // Compile a try-finally clause where the finally block causes a GC
   // while there still is a message pending for external reporting.
   TryCatch try_catch;
   try_catch.SetVerbose(true);
   CompileRun("try { throw new Error(); } finally { gc(); }");
   CHECK(try_catch.HasCaught());
 }