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

src/log.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 144 matching lines @@
     LOG_EVENTS_AND_TAGS_LIST(DECLARE_ENUM)
     NUMBER_OF_LOG_EVENTS
   };
 #undef DECLARE_ENUM
 
   // Acquires resources for logging if the right flags are set.
   bool SetUp();
 
   // Sets the current code event handler.
   void SetCodeEventHandler(uint32_t options,
-                           JitCodeEventHandler event_handler);
+                           JitCodeEventHandler event_handler,
+                           bool support_moved_code);
 
   void EnsureTickerStarted();
   void EnsureTickerStopped();
 
   Sampler* sampler();
 
   // Frees resources acquired in SetUp.
   // When a temporary file is used for the log, returns its stream descriptor,
   // leaving the file open.
   FILE* TearDown();
@@ skipping 63 matching lines @@
                        SharedFunctionInfo* shared,
                        String* source, int line);
   void CodeCreateEvent(LogEventsAndTags tag, Code* code, int args_count);
   void CodeMovingGCEvent();
   // Emits a code create event for a RegExp.
   void RegExpCodeCreateEvent(Code* code, String* source);
   // Emits a code move event.
   void CodeMoveEvent(Address from, Address to);
   // Emits a code delete event.
   void CodeDeleteEvent(Address from);
+  // Emits a code line info add event.
+  void CodeLinePosInfoAddEvent(void* line_info,
+                               int pc_offset,
+                               int position,
+                               JitCodeEvent::PositionType position_type);

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

It seems like passing types associated with JitCodeEvents here is premature,
only the internal implementation of log should know about how to structure the
even and the event's type properly for the JitCodeHandler. I think better would
be to have two APIs in log.h: CodeLinePosInfoAddPositionEvent and
CodeLinePosInfoAddStatementPositionEvent. Internally, they can have the same
implementation, calling the JIT event handler with an event customized with the
proper JitCodeEvent::PositionType, depending on which CodeLinePosInfoAddAddXX
variant it is.

+  // Emits a code line info start to record event
+  void* CodeStartLinePosInfoRecordEvent();
+  // Emits a code line info finish record event.
+  // It's the callee's responsibility to dispose the parameter line_info data.
+  void CodeEndLinePosInfoRecordEvent(Code* code, void* line_info);
 
   void SharedFunctionInfoMoveEvent(Address from, Address to);
 
   void SnapshotPositionEvent(Address addr, int pos);
 
   // ==== Events logged by --log-gc. ====
   // Heap sampling events: start, end, and individual types.
   void HeapSampleBeginEvent(const char* space, const char* kind);
   void HeapSampleEndEvent(const char* space, const char* kind);
   void HeapSampleItemEvent(const char* type, int number, int bytes);
@@ skipping 49 matching lines @@
 
   void RegExpCompileEvent(Handle<JSRegExp> regexp, bool in_cache);
 
   // Log an event reported from generated code
   void LogRuntime(Vector<const char> format, JSArray* args);
 
   bool is_logging() {
     return logging_nesting_ > 0;
   }
 
+  bool is_code_event_handler_enabled() {
+    return code_event_handler_ != NULL;
+  }
+
+  bool is_moved_code_supported() {
+    if (is_code_event_handler_enabled()) {
+      return support_moved_code_;
+    } else {
+      return true;
+    }
+  }
+
   bool is_logging_code_events() {
     return is_logging() || code_event_handler_ != NULL;
   }
 
   // Pause/Resume collection of profiling data.
   // When data collection is paused, CPU Tick events are discarded until
   // data collection is Resumed.
   void PauseProfiler();
   void ResumeProfiler();
   bool IsProfilerPaused();
@@ skipping 23 matching lines @@
   void LogFailure();
 
  private:
   class NameBuffer;
   class NameMap;
 
   Logger();
   ~Logger();
 
   // Issue code notifications.
-  void IssueCodeAddedEvent(Code* code, const char* name, size_t name_len);
+  void IssueCodeAddedEvent(Code* code,
+                           Script* script,
+                           const char* name,
+                           size_t name_len);
   void IssueCodeMovedEvent(Address from, Address to);
   void IssueCodeRemovedEvent(Address from);
-
+  void IssueAddCodeLinePosInfoEvent(void* line_info,
+                                    int pc_offset,
+                                    int position,
+                                    JitCodeEvent::PositionType position_Type);
+  void* IssueStartCodePosInfoEvent();
+  void IssueEndCodePosInfoEvent(Code* code, void* line_info);
   // Emits the profiler's first message.
   void ProfilerBeginEvent();
 
   // Emits callback event messages.
   void CallbackEventInternal(const char* prefix,
                              const char* name,
                              Address entry_point);
 
   // Internal configurable move event.
   void MoveEventInternal(LogEventsAndTags event, Address from, Address to);
@@ skipping 79 matching lines @@
 
   NameMap* address_to_name_map_;
 
   // Guards against multiple calls to TearDown() that can happen in some tests.
   // 'true' between SetUp() and TearDown().
   bool is_initialized_;
 
   // The code event handler - if any.
   JitCodeEventHandler code_event_handler_;
 
+  // Whether the code move is supported when JitCodeEventHandler is set.
+  bool support_moved_code_;
+
   // Support for 'incremental addresses' in compressed logs:
   //  LogMessageBuilder::AppendAddress(Address addr)
   Address last_address_;
   //  Logger::TickEvent(...)
   Address prev_sp_;
   Address prev_function_;
   //  Logger::MoveEventInternal(...)
   Address prev_to_;
   //  Logger::FunctionCreateEvent(...)
   Address prev_code_;
@@ skipping 42 matching lines @@
 // Class that extracts stack trace, used for profiling.
 class StackTracer : public AllStatic {
  public:
   static void Trace(Isolate* isolate, TickSample* sample);
 };
 
 } }  // namespace v8::internal
 
 
 #endif  // V8_LOG_H_