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* line_info,
+                               int pc_offset,
+                               int position,
+                               bool is_statement);
+  // Emits a code line info start to record event
+  void CodeStartLinePosInfoRecordEvent(JITCodeLineInfo* line_info);
+  // 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, JITCodeLineInfo* 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_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(JITCodeLineInfo* line_info,
+                                    int pc_offset,
+                                    int position,
+                                    bool is_statement);
+  void IssueStartCodePosInfoEvent(JITCodeLineInfo* line_info);
+  void IssueEndCodePosInfoEvent(Code* code, JITCodeLineInfo* 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 129 matching lines @@
 
  private:
   static bool ActiveSamplersExist() {
     return active_samplers_ != NULL && !active_samplers_->is_empty();
   }
 
   static List<Sampler*>* active_samplers_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SamplerRegistry);
 };
 

[danno, 2013/01/10 16:47:33]

nit: Google style guide, 2 lines of whitespace between declarations

+// This class is used to record the JITted code position info for JIT
+// code profiling.
+class JITCodeLineInfo : public Malloced {

[danno, 2013/01/10 16:47:33]

As mentioned in the comments for assembler.h, this class doesn't belong anywhere
in the V8 headers. V8 should just pass the event handler line number records,
and the data structure that the handler uses to store the information is the
client's business. 

[chunyang.dai, 2013/01/18 10:22:44]

I defined this class here in previous patch set because I think the V8 can
provide the jit_code_line_info to different 
client, such as vtune, GDB etc. 

I moved this class to vtune-jit.h.

+ 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) { }
+
+    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_;
+};

[danno, 2013/01/10 16:47:33]

nit: Google style guide, 2 lines of whitespace between declarations

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