[WIP] Added CodeEventListener to the sampler API.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
+#include <sstream>
+#include <string>
+
 #include "src/v8.h"
 
 #include "src/ast.h"
 #include "src/base/platform/platform.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
 #include "src/compilation-cache.h"
 #include "src/cpu-profiler.h"
 #include "src/debug.h"
@@ skipping 2322 matching lines @@
 }
 
 
 void Isolate::CountUsage(v8::Isolate::UseCounterFeature feature) {
   if (use_counter_callback_) {
     use_counter_callback_(reinterpret_cast<v8::Isolate*>(this), feature);
   }
 }
 
 
+void Isolate::CodeCreateEvent(Code* code,
+                              const char* comment) {
+  if (code_event_handler() == NULL) return;
+  code_event_handler()->Create(code->address(),
+                               code->ExecutableSize(),
+                               comment);
+}
+
+
+namespace {
+  void AppendVA(char* buf, int buf_size, const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    Vector<char> v(buf, buf_size);
+    v8::internal::VSNPrintF(v, format, args);
+  }
+
+  void AppendStringToStdString(String* str, std::string* std_str) {
+    if (str == NULL) return;
+    DisallowHeapAllocation no_gc;  // Ensure string stay valid.
+
+    int len = str->length();
+    if (len > 0x1000)
+      len = 0x1000;
+    for (int i = 0; i < len; i++) {
+      uc32 c = str->Get(i);
+      if (c > 0xff) {
+        char buf[8];
+        AppendVA(buf, 8, "\\u%04x", c);
+        std_str->append(buf);
+      } else if (c < 32 || c > 126) {
+        char buf[6];
+        snprintf(buf, sizeof(buf), "\\x%02x", c);
+        std_str->append(buf);
+      } else if (c == ',') {
+        std_str->append("\\,");
+      } else if (c == '\\') {
+        std_str->append("\\\\");
+      } else if (c == '\"') {
+        std_str->append("\"\"");
+      } else {
+        char buf[3];
+        AppendVA(buf, 3, "%lc", c);
+        std_str->append(buf);
+      }
+    }
+  }
+
+  void AppendNameToStdString(Name* name, std::string* str) {
+    if (name->IsString()) {
+      AppendStringToStdString(String::cast(name), str);
+    } else {
+      Symbol* symbol = Symbol::cast(name);
+      str->append("symbol(");
+      if (!symbol->name()->IsUndefined()) {
+        str->append("\"");
+        AppendStringToStdString(String::cast(symbol->name()), str);
+        str->append("\" ");
+      }
+      char buf[20];
+      AppendVA(buf, 20, "hash %x)", symbol->Hash());
+      str->append(buf);
+    }
+  }
+}
+
+
+void Isolate::CodeCreateEvent(Code* code,
+                              Name* name) {
+  if (code_event_handler() == NULL) return;
+  std::string code_name;
+  AppendNameToStdString(name, &code_name);
+  code_event_handler()->Create(code->address(),
+                               code->ExecutableSize(),
+                               code_name);
+}
+
+
+void Isolate::CodeCreateEvent(Code* code,
+                              String* regexp_source) {
+  if (code_event_handler() == NULL) return;
+  std::string code_name;
+  AppendStringToStdString(regexp_source, &code_name);
+  code_event_handler()->Create(code->address(),
+                               code->ExecutableSize(),
+                               code_name);
+}
+
+
+void Isolate::CodeCreateEvent(Code* code,
+                              SharedFunctionInfo* shared,
+                              Name* source, int line, int column) {
+  if (code_event_handler() == NULL) return;
+  std::string code_name;
+  SmartArrayPointer<char> name =
+      shared->DebugName()->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
+  code_name.append(name.get());
+  code_name.append(" ");
+  AppendNameToStdString(source, &code_name);
+  std::ostringstream os;
+  os << ":" << line << ":" << column;
+  code_name += os.str();
+  code_event_handler()->Create(code->address(),
+                               code->ExecutableSize(),
+                               code_name);
+}
+
+
+void Isolate::CodeCreateEvent(Address from,
+                              const char* name_prefix,
+                              Name* name) {
+  if (code_event_handler() == NULL) return;
+  std::string code_name;
+  code_name.append(name_prefix);
+  AppendNameToStdString(name, &code_name);
+  code_event_handler()->Create(from,
+                               1,
+                               code_name);
+}
+
+
 bool StackLimitCheck::JsHasOverflowed() const {
   StackGuard* stack_guard = isolate_->stack_guard();
 #ifdef USE_SIMULATOR
   // The simulator uses a separate JS stack.
   Address jssp_address = Simulator::current(isolate_)->get_sp();
   uintptr_t jssp = reinterpret_cast<uintptr_t>(jssp_address);
   if (jssp < stack_guard->real_jslimit()) return true;
 #endif  // USE_SIMULATOR
   return reinterpret_cast<uintptr_t>(this) < stack_guard->real_climit();
 }
 
 
 bool PostponeInterruptsScope::Intercept(StackGuard::InterruptFlag flag) {
   // First check whether the previous scope intercepts.
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal