Logger: extract FLAG_log_code related logging into CodeEventLogger class.

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 429 matching lines @@
 Logger::Logger(Isolate* isolate)
   : isolate_(isolate),
     ticker_(NULL),
     profiler_(NULL),
     log_events_(NULL),
     logging_nesting_(0),
     cpu_profiler_nesting_(0),
     log_(new Log(this)),
     ll_logger_(NULL),
     jit_logger_(NULL),
+    code_logger_(NULL),
     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),
     epoch_(0) {
 }
@@ skipping 475 matching lines @@
 void Logger::NewEventStatic(const char* name, void* object, size_t size) {
   Isolate::Current()->logger()->NewEvent(name, object, size);
 }
 
 
 void Logger::DeleteEventStatic(const char* name, void* object) {
   Isolate::Current()->logger()->DeleteEvent(name, object);
 }
 
 
-void Logger::CallbackEventInternal(const char* prefix, Name* name,
-                                   Address entry_point) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
+class CodeEventLogger {

[yurys, 2013/07/18 18:05:05]

I'd rather extract EventDispatcher into a separate class and keep
CodeEventLoggger a part of Logger. The Logger would become one of the event
listener (like CpuProfiler, LowLevelLogger and others). In other words I'd
extract event dispatching out of Logger and leave only actual logging
functionality here. WDYT?

+ public:
+  explicit CodeEventLogger(Log* log) : log_(log) { }
+  void CallbackEvent(const char* prefix, Name* name, Address entry_point);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       Code* code,
+                       const char* comment);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag, Code* code, Name* name);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       Code* code,
+                       SharedFunctionInfo* shared,
+                       CompilationInfo* info,
+                       Name* name);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       Code* code,
+                       SharedFunctionInfo* shared,
+                       CompilationInfo* info,
+                       Name* source, int line);
+  void CodeCreateEvent(Logger::LogEventsAndTags tag,
+                       Code* code,
+                       int args_count);
+  void RegExpCodeCreateEvent(Code* code, String* source);
+  void CodeMoveEvent(Logger::LogEventsAndTags event, Address from, Address to);
+  void CodeDeleteEvent(Logger::LogEventsAndTags event, Address from);
+
+ private:
+  class CodeCreateMessageBuilder : public Log::MessageBuilder {
+   public:
+    CodeCreateMessageBuilder(Log* log,
+                             Logger::LogEventsAndTags tag,
+                             Code* code)
+        : Log::MessageBuilder(log) {
+      Append("%s,%s,%d,",
+             kLogEventsNames[Logger::CODE_CREATION_EVENT],
+             kLogEventsNames[tag],
+             code->kind());
+      AppendAddress(code->address());
+      Append(",%d,", code->ExecutableSize());
+    }
+  };
+
+  Log* log_;
+};
+
+
+#define CODE_LOG(Call)\
+  if (log_->IsEnabled() && code_logger_)\
+    code_logger_->Call;
+
+
+void CodeEventLogger::CallbackEvent(const char* prefix,
+                                    Name* name,
+                                    Address entry_point) {
   Log::MessageBuilder msg(log_);
   msg.Append("%s,%s,-2,",
-             kLogEventsNames[CODE_CREATION_EVENT],
-             kLogEventsNames[CALLBACK_TAG]);
+             kLogEventsNames[Logger::CODE_CREATION_EVENT],
+             kLogEventsNames[Logger::CALLBACK_TAG]);
   msg.AppendAddress(entry_point);
   if (name->IsString()) {
     SmartArrayPointer<char> str =
         String::cast(name)->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     msg.Append(",1,\"%s%s\"", prefix, *str);
   } else {
     Symbol* symbol = Symbol::cast(name);
     if (symbol->name()->IsUndefined()) {
       msg.Append(",1,symbol(hash %x)", prefix, symbol->Hash());
     } else {
       SmartArrayPointer<char> str = String::cast(symbol->name())->ToCString(
           DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
       msg.Append(",1,symbol(\"%s\" hash %x)", prefix, *str, symbol->Hash());
     }
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CallbackEvent(Name* name, Address entry_point) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
-  CallbackEventInternal("", name, entry_point);
+  CODE_LOG(CallbackEvent("", name, entry_point));
 }
 
 
 void Logger::GetterCallbackEvent(Name* name, Address entry_point) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
-  CallbackEventInternal("get ", name, entry_point);
+  CODE_LOG(CallbackEvent("get ", name, entry_point));
 }
 
 
 void Logger::SetterCallbackEvent(Name* name, Address entry_point) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
-  CallbackEventInternal("set ", name, entry_point);
+  CODE_LOG(CallbackEvent("set ", name, entry_point));
 }
 
 
 void Logger::AppendName(Name* name) {
   if (name->IsString()) {
     name_buffer_->AppendString(String::cast(name));
   } else {
     Symbol* symbol = Symbol::cast(name);
     name_buffer_->AppendBytes("symbol(");
     if (!symbol->name()->IsUndefined()) {
       name_buffer_->AppendBytes("\"");
       name_buffer_->AppendString(String::cast(symbol->name()));
       name_buffer_->AppendBytes("\" ");
     }
     name_buffer_->AppendBytes("hash ");
     name_buffer_->AppendHex(symbol->Hash());
     name_buffer_->AppendByte(')');
   }
 }
 
 
 void Logger::InitNameBuffer(LogEventsAndTags tag) {
-    name_buffer_->Reset();
-    name_buffer_->AppendBytes(kLogEventsNames[tag]);
-    name_buffer_->AppendByte(':');
+  name_buffer_->Reset();
+  name_buffer_->AppendBytes(kLogEventsNames[tag]);
+  name_buffer_->AppendByte(':');
 }
 
 
 void Logger::LogRecordedBuffer(Code* code, SharedFunctionInfo* shared) {
   Script* script = shared && shared->script()->IsScript() ?
       Script::cast(shared->script()) : NULL;
   JIT_LOG(CodeCreateEvent(code, script, name_buffer_->get(),
                           name_buffer_->size()));
   if (!log_->IsEnabled()) return;
   LL_LOG(CodeCreateEvent(code, name_buffer_->get(), name_buffer_->size()));
   if (Serializer::enabled()) {
     RegisterSnapshotCodeName(code, name_buffer_->get(), name_buffer_->size());
   }
 }
 
 
-static void AppendCodeCreateHeader(Log::MessageBuilder* msg,
-                                   Logger::LogEventsAndTags tag,
-                                   Code* code) {
-  ASSERT(msg);
-  msg->Append("%s,%s,%d,",
-              kLogEventsNames[Logger::CODE_CREATION_EVENT],
-              kLogEventsNames[tag],
-              code->kind());
-  msg->AppendAddress(code->address());
-  msg->Append(",%d,", code->ExecutableSize());
-}
-
-
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              const char* comment) {
   if (!is_logging_code_events()) return;
   if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendBytes(comment);
     LogRecordedBuffer(code, NULL);
   }
+  CODE_LOG(CodeCreateEvent(tag, code, comment));
+}
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, tag, code);
+
+void CodeEventLogger::CodeCreateEvent(Logger::LogEventsAndTags tag,
+                                      Code* code,
+                                      const char* comment) {
+  CodeCreateMessageBuilder msg(log_, tag, code);
   msg.AppendDoubleQuotedString(comment);
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              Name* name) {
   if (!is_logging_code_events()) return;
   if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     AppendName(name);
     LogRecordedBuffer(code, NULL);
   }
+  CODE_LOG(CodeCreateEvent(tag, code, name));
+}
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, tag, code);
+
+void CodeEventLogger::CodeCreateEvent(Logger::LogEventsAndTags tag,
+                                      Code* code,
+                                      Name* name) {
+  CodeCreateMessageBuilder msg(log_, tag, code);
   if (name->IsString()) {
     msg.Append('"');
     msg.AppendDetailed(String::cast(name), false);
     msg.Append('"');
   } else {
     msg.AppendSymbolName(Symbol::cast(name));
   }
   msg.Append('\n');
   msg.WriteToLogFile();
 }
@@ skipping 15 matching lines @@
                              CompilationInfo* info,
                              Name* name) {
   if (!is_logging_code_events()) return;
   if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendBytes(ComputeMarker(code));
     AppendName(name);
     LogRecordedBuffer(code, shared);
   }
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  if (code == isolate_->builtins()->builtin(
-      Builtins::kLazyCompile))
-    return;
+  if (code == isolate_->builtins()->builtin(Builtins::kLazyCompile)) return;
+  CODE_LOG(CodeCreateEvent(tag, code, shared, info, name));
+}
 
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, tag, code);
+
+void CodeEventLogger::CodeCreateEvent(Logger::LogEventsAndTags tag,
+                                      Code* code,
+                                      SharedFunctionInfo* shared,
+                                      CompilationInfo* info,
+                                      Name* name) {
+  CodeCreateMessageBuilder msg(log_, tag, code);
   if (name->IsString()) {
     SmartArrayPointer<char> str =
         String::cast(name)->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     msg.Append("\"%s\"", *str);
   } else {
     msg.AppendSymbolName(Symbol::cast(name));
   }
   msg.Append(',');
   msg.AppendAddress(shared->address());
   msg.Append(",%s", ComputeMarker(code));
@@ skipping 21 matching lines @@
     } else {
       name_buffer_->AppendBytes("symbol(hash ");
       name_buffer_->AppendHex(Name::cast(source)->Hash());
       name_buffer_->AppendByte(')');
     }
     name_buffer_->AppendByte(':');
     name_buffer_->AppendInt(line);
     LogRecordedBuffer(code, shared);
   }
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, tag, code);
+  CODE_LOG(CodeCreateEvent(tag, code, shared, info, source, line));
+}
+
+
+void CodeEventLogger::CodeCreateEvent(Logger::LogEventsAndTags tag,
+                                      Code* code,
+                                      SharedFunctionInfo* shared,
+                                      CompilationInfo* info,
+                                      Name* source,
+                                      int line) {
+  CodeCreateMessageBuilder msg(log_, tag, code);
   SmartArrayPointer<char> name =
       shared->DebugName()->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   msg.Append("\"%s ", *name);
   if (source->IsString()) {
     SmartArrayPointer<char> sourcestr =
        String::cast(source)->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     msg.Append("%s", *sourcestr);
   } else {
     msg.AppendSymbolName(Symbol::cast(source));
   }
   msg.Append(":%d\",", line);
   msg.AppendAddress(shared->address());
   msg.Append(",%s", ComputeMarker(code));
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag, Code* code, int args_count) {
   if (!is_logging_code_events()) return;
   if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendInt(args_count);
     LogRecordedBuffer(code, NULL);
   }
+  CODE_LOG(CodeCreateEvent(tag, code, args_count));
+}
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, tag, code);
+
+void CodeEventLogger::CodeCreateEvent(Logger::LogEventsAndTags tag,
+                                      Code* code,
+                                      int args_count) {
+  CodeCreateMessageBuilder msg(log_, tag, code);
   msg.Append("\"args_count: %d\"", args_count);
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeMovingGCEvent() {
   if (!log_->IsEnabled() || !FLAG_ll_prof) return;
   LL_LOG(CodeMovingGCEvent());
   OS::SignalCodeMovingGC();
 }
 
 
 void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
   if (!is_logging_code_events()) return;
   if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(REG_EXP_TAG);
     name_buffer_->AppendString(source);
     LogRecordedBuffer(code, NULL);
   }
+  CODE_LOG(RegExpCodeCreateEvent(code, source));
+}
 
-  if (!FLAG_log_code || !log_->IsEnabled()) return;
-  Log::MessageBuilder msg(log_);
-  AppendCodeCreateHeader(&msg, REG_EXP_TAG, code);
+
+void CodeEventLogger::RegExpCodeCreateEvent(Code* code, String* source) {
+  CodeCreateMessageBuilder msg(log_, Logger::REG_EXP_TAG, code);
   msg.Append('"');
   msg.AppendDetailed(source, false);
   msg.Append('"');
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeMoveEvent(Address from, Address to) {
   JIT_LOG(CodeMovedEvent(from, to));
   if (!log_->IsEnabled()) return;
   LL_LOG(CodeMoveEvent(from, to));
   if (Serializer::enabled() && address_to_name_map_ != NULL) {
     address_to_name_map_->Move(from, to);
   }
-  MoveEventInternal(CODE_MOVE_EVENT, from, to);
+  CODE_LOG(CodeMoveEvent(CODE_MOVE_EVENT, from, to));
 }
 
 
 void Logger::CodeDeleteEvent(Address from) {
   JIT_LOG(CodeRemovedEvent(from));
   if (!log_->IsEnabled()) return;
   LL_LOG(CodeDeleteEvent(from));
   if (Serializer::enabled() && address_to_name_map_ != NULL) {
     address_to_name_map_->Remove(from);
   }
-  DeleteEventInternal(CODE_DELETE_EVENT, from);
+  CODE_LOG(CodeDeleteEvent(CODE_DELETE_EVENT, from));
 }
 
 void Logger::CodeLinePosInfoAddPositionEvent(void* jit_handler_data,
                                      int pc_offset,
                                      int position) {
   JIT_LOG(AddCodeLinePosInfoEvent(jit_handler_data,
                                   pc_offset,
                                   position,
                                   JitCodeEvent::POSITION));
 }
@@ skipping 36 matching lines @@
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[SNAPSHOT_POSITION_EVENT]);
   msg.AppendAddress(addr);
   msg.Append(",%d", pos);
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::SharedFunctionInfoMoveEvent(Address from, Address to) {
-  MoveEventInternal(SHARED_FUNC_MOVE_EVENT, from, to);
+  CODE_LOG(CodeMoveEvent(SHARED_FUNC_MOVE_EVENT, from, to));
 }
 
 
-void Logger::MoveEventInternal(LogEventsAndTags event,
-                               Address from,
-                               Address to) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
+void CodeEventLogger::CodeMoveEvent(Logger::LogEventsAndTags event,
+                                    Address from,
+                                    Address to) {
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[event]);
   msg.AppendAddress(from);
   msg.Append(',');
   msg.AppendAddress(to);
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
-void Logger::DeleteEventInternal(LogEventsAndTags event, Address from) {
-  if (!log_->IsEnabled() || !FLAG_log_code) return;
+void CodeEventLogger::CodeDeleteEvent(Logger::LogEventsAndTags event,
+                                      Address from) {
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[event]);
   msg.AppendAddress(from);
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::ResourceEvent(const char* name, const char* tag) {
   if (!log_->IsEnabled() || !FLAG_log) return;
@@ skipping 579 matching lines @@
     } else {
       logging_nesting_ = 1;
     }
     if (!FLAG_prof_lazy) {
       profiler_->Engage();
     }
   }
 
   if (FLAG_log_internal_timer_events || FLAG_prof) epoch_ = OS::Ticks();
 
+  if (FLAG_log_code) {
+    code_logger_ = new CodeEventLogger(log_);
+  }
+
   return true;
 }
 
 
 void Logger::SetCodeEventHandler(uint32_t options,
                                  JitCodeEventHandler event_handler) {
   if (jit_logger_) {
       delete jit_logger_;
       jit_logger_ = NULL;
   }
@@ skipping 32 matching lines @@
   if (ll_logger_) {
     delete ll_logger_;
     ll_logger_ = NULL;
   }
 
   if (jit_logger_) {
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
+  if (code_logger_) {
+    delete code_logger_;
+    code_logger_ = NULL;
+  }
+
   return log_->Close();
 }
 
 } }  // namespace v8::internal