Extract JitLogger from Logger 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 427 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),
     name_buffer_(new NameBuffer),
     address_to_name_map_(NULL),
     is_initialized_(false),
-    code_event_handler_(NULL),
     last_address_(NULL),
     prev_sp_(NULL),
     prev_function_(NULL),
     prev_to_(NULL),
     prev_code_(NULL),
     epoch_(0) {
 }
 
 
 Logger::~Logger() {
   delete address_to_name_map_;
   delete name_buffer_;
   delete log_;
 }
 
 
-void Logger::IssueCodeAddedEvent(Code* code,
-                                 Script* script,
-                                 const char* name,
-                                 size_t name_len) {
+class JitLogger {
+ public:
+  explicit JitLogger(JitCodeEventHandler code_event_handler);
+
+  void CodeCreateEvent(Code* code, Script* script,
+                       const char* name, size_t name_len);
+  void CodeMovedEvent(Address from, Address to);
+  void CodeRemovedEvent(Address from);
+  void  AddCodeLinePosInfoEvent(
+      void* jit_handler_data,
+      int pc_offset,
+      int position,
+      JitCodeEvent::PositionType position_type);
+  void* StartCodePosInfoEvent();
+  void EndCodePosInfoEvent(Code* code, void* jit_handler_data);
+
+ private:
+  JitCodeEventHandler code_event_handler_;
+};
+
+#define JIT_LOG(Call) if (jit_logger_) jit_logger_->Call;
+
+
+JitLogger::JitLogger(JitCodeEventHandler code_event_handler)
+    : code_event_handler_(code_event_handler) {
+}
+
+
+void JitLogger::CodeCreateEvent(Code* code,
+                                Script* script,
+                                const char* name,
+                                size_t name_len) {
   JitCodeEvent event;
   memset(&event, 0, sizeof(event));
   event.type = JitCodeEvent::CODE_ADDED;
   event.code_start = code->instruction_start();
   event.code_len = code->instruction_size();
   Handle<Script> script_handle =
       script != NULL ? Handle<Script>(script) : Handle<Script>();
   event.script = ToApiHandle<v8::Script>(script_handle);
   event.name.str = name;
   event.name.len = name_len;
 
   code_event_handler_(&event);
 }
 
 
-void Logger::IssueCodeMovedEvent(Address from, Address to) {
+void JitLogger::CodeMovedEvent(Address from, Address to) {
   Code* from_code = Code::cast(HeapObject::FromAddress(from));
 
   JitCodeEvent event;
   event.type = JitCodeEvent::CODE_MOVED;
   event.code_start = from_code->instruction_start();
   event.code_len = from_code->instruction_size();
 
   // Calculate the header size.
   const size_t header_size =
       from_code->instruction_start() - reinterpret_cast<byte*>(from_code);
 
   // Calculate the new start address of the instructions.
   event.new_code_start =
       reinterpret_cast<byte*>(HeapObject::FromAddress(to)) + header_size;
 
   code_event_handler_(&event);
 }
 
 
-void Logger::IssueCodeRemovedEvent(Address from) {
+void JitLogger::CodeRemovedEvent(Address from) {
   Code* from_code = Code::cast(HeapObject::FromAddress(from));
 
   JitCodeEvent event;
   event.type = JitCodeEvent::CODE_REMOVED;
   event.code_start = from_code->instruction_start();
   event.code_len = from_code->instruction_size();
 
   code_event_handler_(&event);
 }
 
-void Logger::IssueAddCodeLinePosInfoEvent(
+void JitLogger::AddCodeLinePosInfoEvent(
     void* jit_handler_data,
     int pc_offset,
     int position,
     JitCodeEvent::PositionType position_type) {
   JitCodeEvent event;
   memset(&event, 0, sizeof(event));
   event.type = JitCodeEvent::CODE_ADD_LINE_POS_INFO;
   event.user_data = jit_handler_data;
   event.line_info.offset = pc_offset;
   event.line_info.pos = position;
   event.line_info.position_type = position_type;
 
   code_event_handler_(&event);
 }
 
 
-void* Logger::IssueStartCodePosInfoEvent() {
+void* JitLogger::StartCodePosInfoEvent() {
   JitCodeEvent event;
   memset(&event, 0, sizeof(event));
   event.type = JitCodeEvent::CODE_START_LINE_INFO_RECORDING;
 
   code_event_handler_(&event);
   return event.user_data;
 }
 
 
-void Logger::IssueEndCodePosInfoEvent(Code* code, void* jit_handler_data) {
+void JitLogger::EndCodePosInfoEvent(Code* code, void* jit_handler_data) {
   JitCodeEvent event;
   memset(&event, 0, sizeof(event));
   event.type = JitCodeEvent::CODE_END_LINE_INFO_RECORDING;
   event.code_start = code->instruction_start();
   event.user_data = jit_handler_data;
 
   code_event_handler_(&event);
 }
 
 #define DECLARE_EVENT(ignore1, name) name,
@@ skipping 420 matching lines @@
 
 
 void Logger::InitNameBuffer(LogEventsAndTags tag) {
     name_buffer_->Reset();
     name_buffer_->AppendBytes(kLogEventsNames[tag]);
     name_buffer_->AppendByte(':');
 }
 
 
 void Logger::LogRecordedBuffer(Code* code, SharedFunctionInfo* shared) {
-  if (code_event_handler_ != NULL) {
-    Script* script = shared && shared->script()->IsScript() ?
-        Script::cast(shared->script()) : NULL;
-    IssueCodeAddedEvent(code,
-                        script,
-                        name_buffer_->get(),
-                        name_buffer_->size());
-  }
+  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());
   }
 }
 
 
 void Logger::AppendCodeCreateHeader(LogMessageBuilder* msg,
                                     LogEventsAndTags tag,
@@ skipping 18 matching lines @@
       msg->Append("\" ");
     }
     msg->Append("hash %x)", symbol->Hash());
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              const char* comment) {
   if (!is_logging_code_events()) return;
-  if (FLAG_ll_prof || Serializer::enabled() || code_event_handler_ != NULL) {
+  if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendBytes(comment);
     LogRecordedBuffer(code, NULL);
   }
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   LogMessageBuilder msg(this);
   AppendCodeCreateHeader(&msg, 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() || code_event_handler_ != NULL) {
+  if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     AppendName(name);
     LogRecordedBuffer(code, NULL);
   }
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   LogMessageBuilder msg(this);
   AppendCodeCreateHeader(&msg, tag, code);
   if (name->IsString()) {
     msg.Append('"');
@@ skipping 16 matching lines @@
   }
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              SharedFunctionInfo* shared,
                              CompilationInfo* info,
                              Name* name) {
   if (!is_logging_code_events()) return;
-  if (FLAG_ll_prof || Serializer::enabled() || code_event_handler_ != NULL) {
+  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;
@@ skipping 17 matching lines @@
 
 // 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,
                              CompilationInfo* info,
                              Name* source, int line) {
   if (!is_logging_code_events()) return;
-  if (FLAG_ll_prof || Serializer::enabled() || code_event_handler_ != NULL) {
+  if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendBytes(ComputeMarker(code));
     name_buffer_->AppendString(shared->DebugName());
     name_buffer_->AppendByte(' ');
     if (source->IsString()) {
       name_buffer_->AppendString(String::cast(source));
     } else {
       name_buffer_->AppendBytes("symbol(hash ");
       name_buffer_->AppendHex(Name::cast(source)->Hash());
       name_buffer_->AppendByte(')');
@@ skipping 19 matching lines @@
   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() || code_event_handler_ != NULL) {
+  if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(tag);
     name_buffer_->AppendInt(args_count);
     LogRecordedBuffer(code, NULL);
   }
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   LogMessageBuilder msg(this);
   AppendCodeCreateHeader(&msg, 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() || code_event_handler_ != NULL) {
+  if (FLAG_ll_prof || Serializer::enabled() || jit_logger_ != NULL) {
     InitNameBuffer(REG_EXP_TAG);
     name_buffer_->AppendString(source);
     LogRecordedBuffer(code, NULL);
   }
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   LogMessageBuilder msg(this);
   AppendCodeCreateHeader(&msg, REG_EXP_TAG, code);
   msg.Append('"');
   msg.AppendDetailed(source, false);
   msg.Append('"');
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeMoveEvent(Address from, Address to) {
-  if (code_event_handler_ != NULL) IssueCodeMovedEvent(from, 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);
 }
 
 
 void Logger::CodeDeleteEvent(Address from) {
-  if (code_event_handler_ != NULL) IssueCodeRemovedEvent(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);
 }
 
 void Logger::CodeLinePosInfoAddPositionEvent(void* jit_handler_data,
                                      int pc_offset,
                                      int position) {
-  if (code_event_handler_ != NULL) {
-    IssueAddCodeLinePosInfoEvent(jit_handler_data,
-                                 pc_offset,
-                                 position,
-                                 JitCodeEvent::POSITION);
-  }
+  JIT_LOG(AddCodeLinePosInfoEvent(jit_handler_data,
+                                  pc_offset,
+                                  position,
+                                  JitCodeEvent::POSITION));
 }
 
 void Logger::CodeLinePosInfoAddStatementPositionEvent(void* jit_handler_data,
                                                       int pc_offset,
                                                       int position) {
-  if (code_event_handler_ != NULL) {
-    IssueAddCodeLinePosInfoEvent(jit_handler_data,
-                                 pc_offset,
-                                 position,
-                                 JitCodeEvent::STATEMENT_POSITION);
-  }
+  JIT_LOG(AddCodeLinePosInfoEvent(jit_handler_data,
+                                  pc_offset,
+                                  position,
+                                  JitCodeEvent::STATEMENT_POSITION));
 }
 
 
 void Logger::CodeStartLinePosInfoRecordEvent(PositionsRecorder* pos_recorder) {
-  if (code_event_handler_ != NULL) {
-      pos_recorder->AttachJITHandlerData(IssueStartCodePosInfoEvent());
+  if (jit_logger_ != NULL) {
+      pos_recorder->AttachJITHandlerData(jit_logger_->StartCodePosInfoEvent());
   }
 }
 
 void Logger::CodeEndLinePosInfoRecordEvent(Code* code,
                                            void* jit_handler_data) {
-  if (code_event_handler_ != NULL) {
-    IssueEndCodePosInfoEvent(code, jit_handler_data);
-  }
+  JIT_LOG(EndCodePosInfoEvent(code, jit_handler_data));
 }
 
 
 void Logger::SnapshotPositionEvent(Address addr, int pos) {
   if (!log_->IsEnabled()) return;
   LL_LOG(SnapshotPositionEvent(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.
     LogMessageBuilder msg(this);
@@ skipping 631 matching lines @@
   }
 
   if (FLAG_log_internal_timer_events || FLAG_prof) epoch_ = OS::Ticks();
 
   return true;
 }
 
 
 void Logger::SetCodeEventHandler(uint32_t options,
                                  JitCodeEventHandler event_handler) {
-  code_event_handler_ = event_handler;
+  if (jit_logger_) {
+      delete jit_logger_;
+      jit_logger_ = NULL;
+  }
 
-  if (code_event_handler_ != NULL && (options & kJitCodeEventEnumExisting)) {
+  if (event_handler) {
+    jit_logger_ = new JitLogger(event_handler);
+  }
+
+  if (jit_logger_ != NULL && (options & kJitCodeEventEnumExisting)) {
     HandleScope scope(isolate_);
     LogCodeObjects();
     LogCompiledFunctions();
   }
 }
 
 
 Sampler* Logger::sampler() {
   return ticker_;
 }
@@ skipping 11 matching lines @@
   }
 
   delete ticker_;
   ticker_ = NULL;
 
   if (ll_logger_) {
     delete ll_logger_;
     ll_logger_ = NULL;
   }
 
+  if (jit_logger_) {
+    delete jit_logger_;
+    jit_logger_ = NULL;
+  }
+
   return log_->Close();
 }
 
 } }  // namespace v8::internal