This patch is the propagation version of https://codereview.chromium.org/10824032 patch

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 2994 matching lines @@
 
 /**
  * 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
+    CODE_REMOVED,
+    CODE_ADD_LINE_POS_INFO,
+    CODE_START_LINE_INFO_RECORDING,
+    CODE_END_LINE_INFO_RECORDING
+  };
+  // Definition of the code position type. See comment for
+  // RelocInfo::kNoPosition field.
+  enum PositionType {
+    POSITION,
+    STATEMENT_POSITION
   };
 
   // Type of event.
   EventType type;
   // Start of the instructions.
   void* code_start;
   // Size of the instructions.
   size_t code_len;
+  // Script info for CODE_ADDED event.
+  Handle<Script> script;
+  // User-defined data for other events. For example, the line_info_struct
+  // for CODE_ADD_LINE_POS_INFO and CODE_END_LINE_INFO_RECORDING event
+  void* user_data;
 
   union {
     // Only valid for CODE_ADDED.
     struct {
       // Name of the object associated with the code, note that the string is
       // not zero-terminated.
       const char* str;
       // Number of chars in str.
       size_t len;
     } name;
+
+    // Only valid for CODE_ADD_LINE_POS_INFO
+    struct {
+      // PC offset
+      size_t offset;
+      // Code postion
+      size_t pos;
+      // The position type.
+      PositionType position_type;
+    } line_info;
+
     // New location of instructions. Only valid for CODE_MOVED.
     void* new_code_start;
   };
 };
 
 /**
  * Option flags passed to the SetJitCodeEventHandler function.
  */
 enum JitCodeEventOptions {
   kJitCodeEventDefault = 0,
@@ skipping 295 matching lines @@
    */
   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 options options for the JIT code event handler.
    * \param event_handler the JIT code event handler, which will be invoked
    *     each time code is added, moved or removed.
+   * \param support_moved_code the code move event is support or not. If it's
+   *     not enabled, the code will NOT be compacted during GC.
    * \note \p event_handler won't get notified of existent code.
    * \note since code removal notifications are not currently issued, the
    *     \p event_handler may get notifications of code that overlaps earlier
    *     code notifications. This happens when code areas are reused, and the
    *     earlier overlapping code areas should therefore be discarded.
    * \note the events passed to \p event_handler and the strings they point to
    *     are not guaranteed to live past each call. The \p event_handler must
    *     copy strings and other parameters it needs to keep around.
    * \note the set of events declared in JitCodeEvent::EventType is expected to
    *     grow over time, and the JitCodeEvent structure is expected to accrue
    *     new members. The \p event_handler function must ignore event codes
    *     it does not recognize to maintain future compatibility.
    */
   static void SetJitCodeEventHandler(JitCodeEventOptions options,
-                                     JitCodeEventHandler event_handler);
+                                     JitCodeEventHandler event_handler,
+                                     bool support_moved_code);

[danno, 2013/02/01 13:43:10]

Id like to avoid baking this into an API. Instead, you should make sure that you
call SetFlagsFromString in V8.h when you install your JIT code handler (or
before, for that matter, specifying the following flag: "--nocompact_code_space"
Middle-term, however, it would be very nice if you support movement in the code
space and remove this restriction.

 
   /**
    * 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.
@@ skipping 1475 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_