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 58 matching lines @@
 // --prof
 // Collect statistical profiling information (ticks), default is off.  The
 // tick profiler requires code events, so --prof implies --log-code.
 
 // Forward declarations.
 class LogMessageBuilder;
 class Profiler;
 class Semaphore;
 class Ticker;
 class Isolate;
+class JITCodeLineInfo;
 
 #undef LOG
 #define LOG(isolate, Call)                          \
   do {                                              \
     v8::internal::Logger* logger =                  \
         (isolate)->logger();                        \
     if (logger->is_logging())                       \
       logger->Call;                                 \
   } while (false)
 
@@ skipping 150 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(JITCodeLineInfo* lineinfostruct,
+                               int pc_offset,
+                               int position,
+                               bool is_statement);
+  // Emits a code line info start to record event
+  void CodeStartLinePosInfoRecordEvent(JITCodeLineInfo* lineinfo);
+  // Emits a code line info finish record event

[danno, 2012/12/20 16:27:20]

Can you add comments about the memory management of the JITCodeLineInfo? After
the detach isn't it the caller's responsibility to dispose the struct?

+  void CodeEndLinePosInfoRecordEvent(Code* code, void* lineinfostruct);
 
   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 92 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(JITCodeLineInfo* lineinfo,

[danno, 2012/12/20 16:27:20]

why not just line_info? Easier to read.

+                                    int pc_offset,
+                                    int position,
+                                    bool is_statement);
+  void IssueStartCodePosInfoEvent(JITCodeLineInfo* lineinfo);

[danno, 2012/12/20 16:27:20]

why not just line_info? Easier to read.

+  void IssueEndCodePosInfoEvent(Code* code, void* lineinfostruct);

[danno, 2012/12/20 16:27:20]

why not just line_info? Easier to read.

   // 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 130 matching lines @@
  private:
   static bool ActiveSamplersExist() {
     return active_samplers_ != NULL && !active_samplers_->is_empty();
   }
 
   static List<Sampler*>* active_samplers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SamplerRegistry);
 };
 
+// This class is used to record the JITted code position info for JIT
+// code profiling.
+class JITCodeLineInfo : public Malloced {
+ public:
+  JITCodeLineInfo() : line_num_info_(10) { }
 
+  void SetPosition(intptr_t pc, int pos, bool is_statement) {
+    AddCodeLineInfo(LineNumInfo(pc, pos, is_statement));
+  }
+
+  struct LineNumInfo {
+    LineNumInfo(intptr_t pc, int pos, bool is_statement)
+                : pc_(pc), pos_(pos), is_statement_(is_statement) { }

[danno, 2012/12/20 16:27:20]

nit: whitespace formatting needs to be according to style guide

+
+    intptr_t pc_;
+    int pos_;
+    bool is_statement_;
+  };
+
+  List<LineNumInfo>* line_numinfo() {
+    return &line_num_info_;
+  }
+
+ private:
+  void AddCodeLineInfo(const LineNumInfo& line_info) {
+    line_num_info_.Add(line_info);
+  }
+  List<LineNumInfo> line_num_info_;
+};
 // 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_