add ETW for V8 symbols

src/log.cc

 // Copyright 2011 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 512 matching lines @@
     logging_nesting_(0),
     cpu_profiler_nesting_(0),
     log_(new Log(this)),
     name_buffer_(new NameBuffer),
     address_to_name_map_(NULL),
     is_initialized_(false),
     last_address_(NULL),
     prev_sp_(NULL),
     prev_function_(NULL),
     prev_to_(NULL),
-    prev_code_(NULL) {
+    prev_code_(NULL),
+    notified_reset_(0) {
 }
 
 
 Logger::~Logger() {
   delete address_to_name_map_;
   delete name_buffer_;
   delete log_;
 }
 
 
@@ skipping 389 matching lines @@
     case Code::OPTIMIZED_FUNCTION: return "*";
     default: return "";
   }
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              SharedFunctionInfo* shared,
                              String* name) {
-  if (!log_->IsEnabled()) return;
+  if (!log_->IsEnabled() && !CodeAddressNotification::IsEnabled()) return;
   if (FLAG_ll_prof || Serializer::enabled()) {
     name_buffer_->Reset();
     name_buffer_->AppendBytes(kLogEventsNames[tag]);
     name_buffer_->AppendByte(':');
     name_buffer_->AppendBytes(ComputeMarker(code));
     name_buffer_->AppendString(name);
   }
   if (FLAG_ll_prof) {
     LowLevelCodeCreateEvent(code, name_buffer_->get(), name_buffer_->size());
   }
   if (Serializer::enabled()) {
     RegisterSnapshotCodeName(code, name_buffer_->get(), name_buffer_->size());
   }
+  if (CodeAddressNotification::IsEnabled()) {
+    name_buffer_->Reset();
+    name_buffer_->AppendString(name);
+    name_buffer_->AppendByte('\0');
+    CodeAddressNotification::WriteSymbolMap(this,
+                                            Add,
+                                            code->instruction_start(),
+                                            code->instruction_size(),
+                                            name_buffer_->get(),
+                                            tag,
+                                            shared->script(),
+                                            0);
+  }
   if (!FLAG_log_code) return;
   if (code == Isolate::Current()->builtins()->builtin(
       Builtins::kLazyCompile))
     return;
 
   LogMessageBuilder msg(this);
   SmartArrayPointer<char> str =
       name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   msg.Append("%s,%s,",
              kLogEventsNames[CODE_CREATION_EVENT],
              kLogEventsNames[tag]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"%s\",", code->ExecutableSize(), *str);
   msg.AppendAddress(shared->address());
   msg.Append(",%s", ComputeMarker(code));
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 // Although, it is possible to extract source and line from
 // the SharedFunctionInfo object, we left it to caller
 // to leave logging functions free from heap allocations.
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              SharedFunctionInfo* shared,
                              String* source, int line) {
-  if (!log_->IsEnabled()) return;
+  if (!log_->IsEnabled() && !CodeAddressNotification::IsEnabled()) return;
   if (FLAG_ll_prof || Serializer::enabled()) {
     name_buffer_->Reset();
     name_buffer_->AppendBytes(kLogEventsNames[tag]);
     name_buffer_->AppendByte(':');
     name_buffer_->AppendBytes(ComputeMarker(code));
     name_buffer_->AppendString(shared->DebugName());
     name_buffer_->AppendByte(' ');
     name_buffer_->AppendString(source);
     name_buffer_->AppendByte(':');
     name_buffer_->AppendInt(line);
   }
   if (FLAG_ll_prof) {
     LowLevelCodeCreateEvent(code, name_buffer_->get(), name_buffer_->size());
   }
   if (Serializer::enabled()) {
     RegisterSnapshotCodeName(code, name_buffer_->get(), name_buffer_->size());
   }
+  if (CodeAddressNotification::IsEnabled()) {
+    name_buffer_->Reset();
+    name_buffer_->AppendString(shared->DebugName());
+    name_buffer_->AppendByte('\0');
+    CodeAddressNotification::WriteSymbolMap(this,
+                                            Add,
+                                            code->instruction_start(),
+                                            code->instruction_size(),
+                                            name_buffer_->get(),
+                                            tag,
+                                            shared->script(),
+                                            line);
+  }
   if (!FLAG_log_code) return;
   LogMessageBuilder msg(this);
   SmartArrayPointer<char> name =
       shared->DebugName()->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   SmartArrayPointer<char> sourcestr =
       source->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   msg.Append("%s,%s,",
              kLogEventsNames[CODE_CREATION_EVENT],
              kLogEventsNames[tag]);
   msg.AppendAddress(code->address());
@@ skipping 36 matching lines @@
 
 
 void Logger::CodeMovingGCEvent() {
   if (!log_->IsEnabled() || !FLAG_ll_prof) return;
   LowLevelLogWriteBytes(&kCodeMovingGCTag, sizeof(kCodeMovingGCTag));
   OS::SignalCodeMovingGC();
 }
 
 
 void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
-  if (!log_->IsEnabled()) return;
+  if (!log_->IsEnabled() && !CodeAddressNotification::IsEnabled()) return;
   if (FLAG_ll_prof || Serializer::enabled()) {
     name_buffer_->Reset();
     name_buffer_->AppendBytes(kLogEventsNames[REG_EXP_TAG]);
     name_buffer_->AppendByte(':');
     name_buffer_->AppendString(source);
   }
   if (FLAG_ll_prof) {
     LowLevelCodeCreateEvent(code, name_buffer_->get(), name_buffer_->size());
   }
   if (Serializer::enabled()) {
     RegisterSnapshotCodeName(code, name_buffer_->get(), name_buffer_->size());
   }
+  if (CodeAddressNotification::IsEnabled()) {
+    name_buffer_->Reset();
+    name_buffer_->AppendBytes(kLogEventsNames[REG_EXP_TAG]);
+    name_buffer_->AppendByte(':');
+    name_buffer_->AppendString(source);
+    name_buffer_->AppendByte('\0');
+    CodeAddressNotification::WriteSymbolMap(this,
+                                            Add,
+                                            code->instruction_start(),
+                                            code->instruction_size(),
+                                            name_buffer_->get(),
+                                            REG_EXP_TAG,
+                                            NULL,
+                                            0);
+  }
   if (!FLAG_log_code) return;
   LogMessageBuilder msg(this);
   msg.Append("%s,%s,",
              kLogEventsNames[CODE_CREATION_EVENT],
              kLogEventsNames[REG_EXP_TAG]);
   msg.AppendAddress(code->address());
   msg.Append(",%d,\"", code->ExecutableSize());
   msg.AppendDetailed(source, false);
   msg.Append('\"');
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeMoveEvent(Address from, Address to) {
-  if (!log_->IsEnabled()) return;
+  if (!log_->IsEnabled() && !CodeAddressNotification::IsEnabled()) return;
   if (FLAG_ll_prof) LowLevelCodeMoveEvent(from, to);
   if (Serializer::enabled() && address_to_name_map_ != NULL) {
     address_to_name_map_->Move(from, to);
   }
+  if (CodeAddressNotification::IsEnabled()) {
+    CodeAddressNotification::WriteSymbolMap(this,
+                                            Move,
+                                            from,
+                                            0,
+                                            NULL,
+                                            CODE_MOVE_EVENT,
+                                            to,
+                                            0);
+  }
   MoveEventInternal(CODE_MOVE_EVENT, from, to);
 }
 
 
 void Logger::CodeDeleteEvent(Address from) {
-  if (!log_->IsEnabled()) return;
+  if (!log_->IsEnabled() && !CodeAddressNotification::IsEnabled()) return;
   if (FLAG_ll_prof) LowLevelCodeDeleteEvent(from);
   if (Serializer::enabled() && address_to_name_map_ != NULL) {
     address_to_name_map_->Remove(from);
   }
+  if (CodeAddressNotification::IsEnabled()) {
+    CodeAddressNotification::WriteSymbolMap(this,
+                                            Remove,
+                                            from,
+                                            0,
+                                            NULL,
+                                            CODE_DELETE_EVENT,
+                                            NULL,
+                                            0);
+  }
   DeleteEventInternal(CODE_DELETE_EVENT, from);
 }
 
 
 void Logger::SnapshotPositionEvent(Address addr, int pos) {
   if (!log_->IsEnabled()) return;
   if (FLAG_ll_prof) LowLevelSnapshotPositionEvent(addr, pos);
   if (Serializer::enabled() && address_to_name_map_ != NULL) {
     const char* code_name = address_to_name_map_->Lookup(addr);
     if (code_name == NULL) return;  // Not a code object.
@@ skipping 207 matching lines @@
 void Logger::LogFailure() {
   PauseProfiler();
 }
 
 
 bool Logger::IsProfilerSamplerActive() {
   return ticker_->IsActive();
 }
 
 
+// This returns true if API callback for symbol address is enabled.
+bool Logger::CodeAddressCallbackEnabled() {
+  return CodeAddressNotification::IsEnabled();
+}
+
+
 class EnumerateOptimizedFunctionsVisitor: public OptimizedFunctionVisitor {
  public:
   EnumerateOptimizedFunctionsVisitor(Handle<SharedFunctionInfo>* sfis,
                                      Handle<Code>* code_objects,
                                      int* count)
       : sfis_(sfis), code_objects_(code_objects), count_(count) { }
 
   virtual void EnterContext(Context* context) {}
   virtual void LeaveContext(Context* context) {}
 
@@ skipping 444 matching lines @@
 
 void SamplerRegistry::RemoveActiveSampler(Sampler* sampler) {
   ASSERT(sampler->IsActive());
   ScopedLock lock(active_samplers_mutex);
   ASSERT(active_samplers_ != NULL);
   bool removed = active_samplers_->RemoveElement(sampler);
   ASSERT(removed);
   USE(removed);
 }
 
+
+// External code address mapping notifications.
+
+// Counter to indicate that enumeration of compiled functions is required.
+// Incremented each time notification enabled and enumeration requested.
+// Callback setting is not isolated. Set global and check from each logger.
+volatile Atomic32 NeedReset = 0;
+Atomic32 EnumIncr = 1;
+// The current callback (only one)
+volatile AtomicWord ExtCallback = NULL;
+
+// Called by host to set callbacks - null turns off callbacks.
+// Callback may still be called after it is turned off. The caller must
+// close the isolate before unloading the callback code.
+void CodeAddressNotification::SetCodeAddressEventCallback(CodeAddressEvent cb,
+                                                          bool enumExisting) {
+  AtomicWord newcb = (AtomicWord)cb;
+  AtomicWord old = NoBarrier_AtomicExchange(&ExtCallback, newcb);
+
+  if (cb != NULL && enumExisting) {
+    NoBarrier_AtomicIncrement(&NeedReset, EnumIncr);
+  }
+}
+
+
+// Called by v8 when a symbol map is created or changed.
+void CodeAddressNotification::WriteSymbolMap(Logger* logger,
+                                             CodeAddressOperation op,
+                                             const void* addr1,
+                                             int len,
+                                             const char* symbol,
+                                             Logger::LogEventsAndTags tag,
+                                             const void* addr2,
+                                             int line) {
+  CodeAddressEvent cb = (CodeAddressEvent)ExtCallback;
+  if (cb != NULL) {
+    if (logger->notified_reset_ < NeedReset) {
+        // Enumeration needed. Log a reset, then log existing functions.
+        logger->notified_reset_ = NeedReset;
+        cb(CodeAddressOperation::Reset,
+            NULL,
+            0,
+            "",
+            Logger::CODE_CREATION_EVENT,
+            NULL,
+            0);
+        logger->LogCompiledFunctions();
+    }
+
+    if (op == Add) {
+      switch (tag) {
+        case Logger::SCRIPT_TAG:
+        case Logger::NATIVE_SCRIPT_TAG:
+          op = Source;
+          break;
+        case Logger::FUNCTION_TAG:
+        case Logger::LAZY_COMPILE_TAG:
+        case Logger::NATIVE_FUNCTION_TAG:
+        case Logger::NATIVE_LAZY_COMPILE_TAG:
+        case Logger::REG_EXP_TAG:
+          break;
+        default:
+          return;
+      }
+    }
+    cb(op, addr1, len, symbol, static_cast<int>(tag), addr2, line);
+  }
+}
+
+
+// Called by v8 to determine if callbacks are enabled.
+bool CodeAddressNotification::IsEnabled() {
+  return ExtCallback != NULL;
+}
+
 } }  // namespace v8::internal