C++ profiles processor: wire up to VM.

src/log.cc

 // Copyright 2009 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 125 matching lines @@
   static bool paused_;
 };
 
 bool Profiler::paused_ = false;
 
 
 //
 // StackTracer implementation
 //
 void StackTracer::Trace(TickSample* sample) {
-  if (sample->state == GC) {
-    sample->frames_count = 0;
-    return;
-  }
+  sample->function = NULL;
+  sample->frames_count = 0;
+
+  if (sample->state == GC) return;
 
   const Address js_entry_sp = Top::js_entry_sp(Top::GetCurrentThread());
   if (js_entry_sp == 0) {
     // Not executing JS now.
-    sample->frames_count = 0;
     return;
   }
 
   const Address functionAddr =
       sample->fp + JavaScriptFrameConstants::kFunctionOffset;
   if (SafeStackFrameIterator::IsWithinBounds(sample->sp, js_entry_sp,
                                              functionAddr)) {
     sample->function = Memory::Address_at(functionAddr) - kHeapObjectTag;
   }
 
@@ skipping 11 matching lines @@
     it.Advance();
   }
   sample->frames_count = i;
 }
 
 
 //
 // Ticker used to provide ticks to the profiler and the sliding state
 // window.
 //
+#ifndef ENABLE_CPP_PROFILES_PROCESSOR
+
 class Ticker: public Sampler {
  public:
   explicit Ticker(int interval):
       Sampler(interval, FLAG_prof), window_(NULL), profiler_(NULL) {}
 
   ~Ticker() { if (IsActive()) Stop(); }
 
   void SampleStack(TickSample* sample) {
     StackTracer::Trace(sample);
   }
@@ skipping 21 matching lines @@
   void ClearProfiler() {
     profiler_ = NULL;
     if (!window_ && IsActive()) Stop();
   }
 
  private:
   SlidingStateWindow* window_;
   Profiler* profiler_;
 };
 
+#endif  // ENABLE_CPP_PROFILES_PROCESSOR
+
 
 //
 // SlidingStateWindow implementation.
 //
 SlidingStateWindow::SlidingStateWindow(): current_index_(0), is_full_(false) {
   for (int i = 0; i < kBufferSize; i++) {
     buffer_[i] = static_cast<byte>(OTHER);
   }
   Logger::ticker_->SetWindow(this);
 }
@@ skipping 1056 matching lines @@
         break;
       case Code::KEYED_STORE_IC:
         description = "A keyed store IC from the snapshot";
         tag = Logger::KEYED_STORE_IC_TAG;
         break;
       case Code::CALL_IC:
         description = "A call IC from the snapshot";
         tag = Logger::CALL_IC_TAG;
         break;
     }
-    LOG(CodeCreateEvent(tag, code_object, description));
+    PROFILE(CodeCreateEvent(tag, code_object, description));
   }
 }
 
 
 void Logger::LogCodeObjects() {
   AssertNoAllocation no_alloc;
   HeapIterator iterator;
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (obj->IsCode()) LogCodeObject(obj);
   }
@@ skipping 13 matching lines @@
     Handle<SharedFunctionInfo> shared = sfis[i];
     Handle<String> name(String::cast(shared->name()));
     Handle<String> func_name(name->length() > 0 ?
                              *name : shared->inferred_name());
     if (shared->script()->IsScript()) {
       Handle<Script> script(Script::cast(shared->script()));
       if (script->name()->IsString()) {
         Handle<String> script_name(String::cast(script->name()));
         int line_num = GetScriptLineNumber(script, shared->start_position());
         if (line_num > 0) {
-          LOG(CodeCreateEvent(Logger::LAZY_COMPILE_TAG,
-                              shared->code(), *func_name,
-                              *script_name, line_num + 1));
+          PROFILE(CodeCreateEvent(Logger::LAZY_COMPILE_TAG,
+                                  shared->code(), *func_name,
+                                  *script_name, line_num + 1));
         } else {
           // Can't distinguish enum and script here, so always use Script.
-          LOG(CodeCreateEvent(Logger::SCRIPT_TAG,
-                              shared->code(), *script_name));
+          PROFILE(CodeCreateEvent(Logger::SCRIPT_TAG,
+                                  shared->code(), *script_name));
         }
       } else {
-        LOG(CodeCreateEvent(
+        PROFILE(CodeCreateEvent(
             Logger::LAZY_COMPILE_TAG, shared->code(), *func_name));
       }
     } else if (shared->IsApiFunction()) {
       // API function.
       FunctionTemplateInfo* fun_data = shared->get_api_func_data();
       Object* raw_call_data = fun_data->call_code();
       if (!raw_call_data->IsUndefined()) {
         CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
         Object* callback_obj = call_data->callback();
         Address entry_point = v8::ToCData<Address>(callback_obj);
-        LOG(CallbackEvent(*func_name, entry_point));
+        PROFILE(CallbackEvent(*func_name, entry_point));
       }
     } else {
-      LOG(CodeCreateEvent(
+      PROFILE(CodeCreateEvent(
           Logger::LAZY_COMPILE_TAG, shared->code(), *func_name));
     }
   }
 
   DeleteArray(sfis);
 }
 
 
 void Logger::LogFunctionObjects() {
   AssertNoAllocation no_alloc;
   HeapIterator iterator;
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (!obj->IsJSFunction()) continue;
     JSFunction* jsf = JSFunction::cast(obj);
     if (!jsf->is_compiled()) continue;
-    LOG(FunctionCreateEvent(jsf));
+    PROFILE(FunctionCreateEvent(jsf));
   }
 }
 
 
 void Logger::LogAccessorCallbacks() {
   AssertNoAllocation no_alloc;
   HeapIterator iterator;
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (!obj->IsAccessorInfo()) continue;
     AccessorInfo* ai = AccessorInfo::cast(obj);
     if (!ai->name()->IsString()) continue;
     String* name = String::cast(ai->name());
     Address getter_entry = v8::ToCData<Address>(ai->getter());
     if (getter_entry != 0) {
-      LOG(GetterCallbackEvent(name, getter_entry));
+      PROFILE(GetterCallbackEvent(name, getter_entry));
     }
     Address setter_entry = v8::ToCData<Address>(ai->setter());
     if (setter_entry != 0) {
-      LOG(SetterCallbackEvent(name, setter_entry));
+      PROFILE(SetterCallbackEvent(name, setter_entry));
     }
   }
 }
 
 #endif
 
 
 bool Logger::Setup() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // --log-all enables all the log flags.
@@ skipping 92 matching lines @@
     if (!FLAG_prof_auto) {
       profiler_->pause();
     } else {
       logging_nesting_ = 1;
     }
     if (!FLAG_prof_lazy) {
       profiler_->Engage();
     }
   }
 
+#ifdef ENABLE_CPP_PROFILES_PROCESSOR
+  // Disable old logging, as we are using the same '--prof' flag.
+  logging_nesting_ = 0;
+#endif
+
   LogMessageBuilder::set_write_failure_handler(StopLoggingAndProfiling);
 
   return true;
 
 #else
   return false;
 #endif
 }
 
 
@@ skipping 33 matching lines @@
     return;
   }
   // Otherwise, if the sliding state window computation has not been
   // started we do it now.
   if (sliding_state_window_ == NULL) {
     sliding_state_window_ = new SlidingStateWindow();
   }
 #endif
 }
 
-
 } }  // namespace v8::internal