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

include/v8.h

 // 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 2926 matching lines @@
  *    return address resides. This can be used to identify the caller of
  *    \p function, and/or modified to divert execution when \p function exits.
  *
  * \note the entry hook must not cause garbage collection.
  */
 typedef void (*FunctionEntryHook)(uintptr_t function,
                                   uintptr_t return_addr_location);
 
 
 /**
+ * A JIT code event is issued each time code is added, moved or removed.
+ *
+ * \note removal events are not currently issued.
+ */
+struct JitCodeEvent {
+  enum EventType {
+    CODE_ADDED,
+    CODE_MOVED,
+    CODE_REMOVED
+  };
+
+  EventType type;
+  // Start of the instructions.
+  void* code_start;
+  // Size of the instructions.
+  size_t code_len;
+  union {
+    // Name of the object associated with the code. Only valid for CODE_ADDED.
+    const char* name;
+    // New location of instructions. Only valid for CODE_MOVED.
+    void* new_code_start;
+  };
+};
+
+
+/**
+ * Callback function passed to SetJitCodeEventHandler.
+ *
+ * \param event code add, move or removal event.
+ */
+typedef void (*JitCodeEventHandler)(const JitCodeEvent* event);
+
+
+/**
  * Interface for iterating though all external resources in the heap.
  */
 class V8EXPORT ExternalResourceVisitor {  // NOLINT
  public:
   virtual ~ExternalResourceVisitor() {}
   virtual void VisitExternalString(Handle<String> string) {}
 };
 
 
 /**
@@ skipping 254 matching lines @@
    *
    * \param entry_hook a function that will be invoked on entry to every
    *   V8-generated function.
    * \returns true on success on supported platforms, false on failure.
    * \note Setting a new entry hook function when one is already active will
    *   fail.
    */
   static bool SetFunctionEntryHook(FunctionEntryHook entry_hook);
 
   /**
+   * Allows the host application to provide the address of a function that is
+   * notified each time code is added, moved or removed.

[mnaganov (inactive), 2012/07/25 14:22:12]

There is a problem with code objects that were created before the handler has
been set. For V8's profiler we walk the heap in order to enumerate them prior to
hooking on events. Otherwise, the client will be receiving code move events for
objects he doesn't know anything about.

Or you need to require that the client must set the handler in the very
beginning.

[Sigurður Ásgeirsson, 2012/07/25 14:38:35]

This is true - for the use case I have in mind, there's no problem simply
requiring that the hook is instated before initializing V8.
Do you have other use cases in mind here?
Would you like me to change the API, the documentation or both, and if so, how?

[mnaganov (inactive), 2012/07/25 14:43:48]

For me, just stating this in the doc would be fine. If in the future this
restriction will be removed by adding scanning of current code objects on
handler installation, this wouldn't affect clients that install the handler from
the beginning.

[Sigurður Ásgeirsson, 2012/07/27 13:25:24]

Done.

+   *
+   * \param event_handler the JIT code event handler, which will be invoked
+   *     each time code is added, moved or removed.
+   */
+  static void SetJitCodeEventHandler(JitCodeEventHandler event_handler);
+
+  /**
    * Adjusts the amount of registered external memory.  Used to give
    * V8 an indication of the amount of externally allocated memory
    * that is kept alive by JavaScript objects.  V8 uses this to decide
    * when to perform global garbage collections.  Registering
    * externally allocated memory will trigger global garbage
    * collections more often than otherwise in an attempt to garbage
    * collect the JavaScript objects keeping the externally allocated
    * memory alive.
    *
    * \param change_in_bytes the change in externally allocated memory
@@ skipping 1304 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_