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.
+   *
+   * \param event_handler the JIT code event handler, which will be invoked
+   *     each time code is added, moved or removed.
+   * \note \p event_handler won't get notified of existent code.

[mnaganov (inactive), 2012/07/30 11:43:36]

One more thing worth mentioning here -- because of missing code deletion events,
it will be possible for code addition events to arrive having code addresses
that overlap with previously added code objects. The client needs to delete all
overlapping code objects first, as they were in fact removed during GC.

Sorry I forgot about this issue initially.

[Sigurður Ásgeirsson, 2012/07/30 13:54:43]

Thanks! Added docs regarding overlap and string/event lifetimes.

+   */
+  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_