Added the simplest call stack sampling and call profile in tick processor output.

src/log.cc

 // Copyright 2006-2008 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 121 matching lines @@
 
 bool Profiler::paused_ = false;
 
 
 //
 // Ticker used to provide ticks to the profiler and the sliding state
 // window.
 //
 class Ticker: public Sampler {
  public:
-  explicit Ticker(int interval):
-      Sampler(interval, FLAG_prof), window_(NULL), profiler_(NULL) {}
+  explicit Ticker(int interval, unsigned int low_stack_bound):
+      Sampler(interval, FLAG_prof), window_(NULL), profiler_(NULL),
+      low_stack_bound_(low_stack_bound) {}
 
   ~Ticker() { if (IsActive()) Stop(); }
 
   void Tick(TickSample* sample) {
+    if (IsProfiling()) SampleStack(sample);
     if (profiler_) profiler_->Insert(sample);
     if (window_) window_->AddState(sample->state);
   }
 
   void SetWindow(SlidingStateWindow* window) {
     window_ = window;
     if (!IsActive()) Start();
   }
 
   void ClearWindow() {
     window_ = NULL;
     if (!profiler_ && IsActive()) Stop();
   }
 
   void SetProfiler(Profiler* profiler) {
     profiler_ = profiler;
     if (!IsActive()) Start();
   }
 
   void ClearProfiler() {
     profiler_ = NULL;
     if (!window_ && IsActive()) Stop();
   }
 
  private:
+  void SampleStack(TickSample* sample) {
+    // Assuming that stack grows from lower addresses
+    if (sample->sp < sample->fp && sample->fp < low_stack_bound_) {
+      sample->InitStack(1);
+      sample->stack[0] = Memory::Address_at(
+          (Address)(sample->fp + StandardFrameConstants::kCallerPCOffset));
+    } else {
+      // FP seems to be in some intermediate state, better discard this sample
+      sample->InitStack(0);
+    }
+  }
+
   SlidingStateWindow* window_;
   Profiler* profiler_;
+  unsigned int low_stack_bound_;
 };
 
 
 //
 // SlidingStateWindow implementation.
 //
 SlidingStateWindow::SlidingStateWindow(): current_index_(0), is_full_(false) {
   for (int i = 0; i < kBufferSize; i++) {
     buffer_[i] = static_cast<byte>(OTHER);
   }
@@ skipping 47 matching lines @@
 
 void Profiler::Disengage() {
   // Stop receiving ticks.
   Logger::ticker_->ClearProfiler();
 
   // Terminate the worker thread by setting running_ to false,
   // inserting a fake element in the queue and then wait for
   // the thread to terminate.
   running_ = false;
   TickSample sample;
-  sample.pc = 0;
-  sample.sp = 0;
-  sample.state = OTHER;
   Insert(&sample);
   Join();
 
   LOG(UncheckedStringEvent("profiler", "end"));
 }
 
 
 void Profiler::Run() {
   TickSample sample;
   bool overflow = Logger::profiler_->Remove(&sample);
@@ skipping 638 matching lines @@
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 void Logger::TickEvent(TickSample* sample, bool overflow) {
   if (logfile_ == NULL || !FLAG_prof) return;
   LogMessageBuilder msg;
   msg.Append("tick,0x%x,0x%x,%d", sample->pc, sample->sp,
              static_cast<int>(sample->state));
   if (overflow) {
     msg.Append(",overflow");
   }
+  if (*(sample->stack)) {
+    for (size_t i = 0; sample->stack[i]; ++i) {
+      msg.Append(",0x%x", reinterpret_cast<unsigned int>(sample->stack[i]));
+    }
+  }
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 bool Logger::IsProfilerPaused() {
   return profiler_->paused();
 }
 
 
@@ skipping 70 matching lines @@
       logfile_ = OS::FOpen(*expanded, "w");
     } else {
       logfile_ = OS::FOpen(FLAG_logfile, "w");
     }
     message_buffer_ = NewArray<char>(kMessageBufferSize);
     mutex_ = OS::CreateMutex();
   }
 
   current_state_ = new VMState(OTHER);
 
-  ticker_ = new Ticker(10);
+  // as log is initialized early with V8, we can assume that JS execution
+  // frames can never reach this point on stack
+  int stack_var;
+  ticker_ = new Ticker(10, reinterpret_cast<unsigned int>(&stack_var));
 
   if (FLAG_sliding_state_window && sliding_state_window_ == NULL) {
     sliding_state_window_ = new SlidingStateWindow();
   }
 
   if (FLAG_prof) {
     profiler_ = new Profiler();
     if (!FLAG_prof_auto)
       profiler_->pause();
     profiler_->Engage();
@@ skipping 94 matching lines @@
   if (FLAG_log_state_changes) {
     LOG(UncheckedStringEvent("Leaving", StateToString(state_)));
     if (previous_) {
       LOG(UncheckedStringEvent("To", StateToString(previous_->state_)));
     }
   }
 }
 #endif
 
 } }  // namespace v8::internal