Add logging of callbacks in prof-lazy mode.

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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdarg.h>
 
 #include "v8.h"
 
 #include "bootstrapper.h"
+#include "global-handles.h"
 #include "log.h"
 #include "macro-assembler.h"
 #include "serialize.h"
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
@@ skipping 587 matching lines @@
 void Logger::DeleteEvent(const char* name, void* object) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (!Log::IsEnabled() || !FLAG_log) return;
   LogMessageBuilder msg;
   msg.Append("delete,%s,0x%" V8PRIxPTR "\n", name, object);
   msg.WriteToLogFile();
 #endif
 }
 
 
+void Logger::CallbackEvent(const char* class_name, const char* method_name,
+                           Address entry_point) {
+#ifdef ENABLE_LOGGING_AND_PROFILING
+  if (!Log::IsEnabled() || !FLAG_log_code) return;
+  LogMessageBuilder msg;
+  msg.Append("%s,%s,",
+             log_events_[CODE_CREATION_EVENT], log_events_[CALLBACK_TAG]);
+  msg.AppendAddress(entry_point);
+  msg.Append(",0,\"");
+  if (class_name != NULL) {
+    msg.Append("%s.", class_name);
+  }
+  msg.Append("%s\"\n", method_name);
+  msg.WriteToLogFile();
+#endif
+}
+
+
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 // A class that contains all common code dealing with record compression.
 class CompressionHelper {
  public:
   explicit CompressionHelper(int window_size)
       : compressor_(window_size), repeat_count_(0) { }
 
   // Handles storing message in compressor, retrieving the previous one and
   // prefixing it with repeat count, if needed.
@@ skipping 414 matching lines @@
   const int modules_to_enable = ~GetActiveProfilerModules() & flags;
   if (modules_to_enable != PROFILER_MODULE_NONE) {
     is_logging_ = true;
   }
   if (modules_to_enable & PROFILER_MODULE_CPU) {
     if (FLAG_prof_lazy) {
       profiler_->Engage();
       LOG(UncheckedStringEvent("profiler", "resume"));
       FLAG_log_code = true;
       LogCompiledFunctions();
+      LogCallbacks();
       if (!FLAG_sliding_state_window) ticker_->Start();
     }
     profiler_->resume();
   }
   if (modules_to_enable &
       (PROFILER_MODULE_HEAP_STATS | PROFILER_MODULE_JS_CONSTRUCTORS)) {
     FLAG_log_gc = true;
   }
 }
 
@@ skipping 110 matching lines @@
         continue;
       }
     }
     // If no script or script has no name.
     LOG(CodeCreateEvent(Logger::LAZY_COMPILE_TAG, shared->code(), *func_name));
   }
 
   DeleteArray(sfis);
 }
 
+
+namespace {
+
+class FunctionTemplateInfosVisitor : public ObjectVisitor {
+ public:
+  virtual ~FunctionTemplateInfosVisitor() {}
+  virtual void VisitPointers(Object** start, Object** end) {
+    for (Object** p = start; p < end; ++p) {
+      VisitFTI(*p);
+    }
+  }
+
+ private:
+  void VisitFTI(Object* o) {
+    // The data about callbacks is in fact dynamically typed
+    // (Object ptrs are used), so we use runtime type checking
+    // to be sure that we retrieve the right thing.
+    if (!o->IsFunctionTemplateInfo())
+      return;
+    AssertNoAllocation no_alloc;
+    FunctionTemplateInfo* fti = FunctionTemplateInfo::cast(o);
+    if (!fti->prototype_template()->IsObjectTemplateInfo())
+      return;
+    SmartPointer<char> class_name;
+    if (fti->class_name()->IsString()) {
+      class_name = String::cast(fti->class_name())->
+          ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
+    }
+    ObjectTemplateInfo* proto =
+        ObjectTemplateInfo::cast(fti->prototype_template());
+    NeanderArray props(Handle<Object>(proto->property_list()));
+    // Properties are triples: [property name, entry point, attributes].
+    // See Template::Set in api.cc.
+    for (int i = 0; i < props.length(); i += 3) {
+      if (!props.get(i)->IsString()
+          || !props.get(i + 1)->IsFunctionTemplateInfo())
+        continue;
+      FunctionTemplateInfo* native_fti =
+          FunctionTemplateInfo::cast(props.get(i + 1));
+      Object* raw_call_data = native_fti->call_code();
+      if (raw_call_data->IsUndefined())
+        continue;
+      CallHandlerInfo* call_data = CallHandlerInfo::cast(raw_call_data);
+      Object* callback_obj = call_data->callback();
+      Address entry_point = v8::ToCData<Address>(callback_obj);
+      SmartPointer<char> method_name(
+          String::cast(props.get(i))->
+          ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL));
+      LOG(CallbackEvent(*class_name, *method_name, entry_point));
+    }
+  }
+};
+
+}  // anonymous namespace
+
+
+void Logger::LogCallbacks() {
+  // We are looking for callbacks information exposed via persistent
+  // FunctionTemplate objects.
+  FunctionTemplateInfosVisitor visitor;
+  GlobalHandles::IterateStrongRoots(&visitor);
+}
+
 #endif
 
 
 bool Logger::Setup() {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   // --log-all enables all the log flags.
   if (FLAG_log_all) {
     FLAG_log_runtime = true;
     FLAG_log_api = true;
     FLAG_log_code = true;
@@ skipping 141 matching lines @@
   // 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