Fixed numerous issues that were causing errors in profiler log processing

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 281 matching lines @@
   explicit LogMessageBuilder();
   ~LogMessageBuilder() { }
 
   void Append(const char* format, ...);
   void Append(const char* format, va_list args);
   void Append(const char c);
   void Append(String *str);
   void AppendDetailed(String* str, bool show_impl_info);
 
   void WriteToLogFile();
+  void WriteCStringToLogFile(const char* str);
 
  private:
   ScopedLock sl;
   int pos_;
 };
 
 
 // Create a message builder starting from position 0. This acquires the mutex
 // in the logger as well.
 LogMessageBuilder::LogMessageBuilder(): sl(Logger::mutex_), pos_(0) {
@@ skipping 76 matching lines @@
   }
 }
 
 // Write the log message to the log file currently opened.
 void LogMessageBuilder::WriteToLogFile() {
   ASSERT(pos_ <= Logger::kMessageBufferSize);
   size_t rv = fwrite(Logger::message_buffer_, 1, pos_, Logger::logfile_);
   ASSERT(rv == static_cast<size_t>(pos_));
   USE(rv);
 }
+
+// Write a null-terminated string to to the log file currently opened.
+void LogMessageBuilder::WriteCStringToLogFile(const char* str) {
+  size_t len = strlen(str);
+  size_t rv = fwrite(str, 1, len, Logger::logfile_);
+  ASSERT(rv == len);
+  USE(rv);
+}
 #endif
 
 
 //
 // Logger class implementation.
 //
 Ticker* Logger::ticker_ = NULL;
 char* Logger::message_buffer_ = NULL;
 FILE* Logger::logfile_ = NULL;
 Profiler* Logger::profiler_ = NULL;
 Mutex* Logger::mutex_ = NULL;
 VMState* Logger::current_state_ = NULL;
 VMState Logger::bottom_state_(EXTERNAL);
 SlidingStateWindow* Logger::sliding_state_window_ = NULL;
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 
 void Logger::Preamble(const char* content) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_code) return;
   LogMessageBuilder msg;
-  msg.Append("%s", content);
-  msg.WriteToLogFile();
+  msg.WriteCStringToLogFile(content);
 #endif
 }
 
 
 void Logger::StringEvent(const char* name, const char* value) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (FLAG_log) UncheckedStringEvent(name, value);
 #endif
 }
 
@@ skipping 319 matching lines @@
   LogMessageBuilder msg;
   msg.Append("code-creation,%s,0x%x,%d,\"args_count: %d\"\n", tag,
              reinterpret_cast<unsigned int>(code->address()),
              code->ExecutableSize(),
              args_count);
   msg.WriteToLogFile();
 #endif
 }
 
 
+void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
+#ifdef ENABLE_LOGGING_AND_PROFILING
+  if (logfile_ == NULL || !FLAG_log_code) return;
+  LogMessageBuilder msg;
+  msg.Append("code-creation,%s,0x%x,%d,\"", "RegExp",
+             reinterpret_cast<unsigned int>(code->address()),
+             code->ExecutableSize());
+  msg.AppendDetailed(source, false);
+  msg.Append("\"\n");
+  msg.WriteToLogFile();
+#endif
+}
+
+
 void Logger::CodeAllocateEvent(Code* code, Assembler* assem) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (logfile_ == NULL || !FLAG_log_code) return;
   LogMessageBuilder msg;
   msg.Append("code-allocate,0x%x,0x%x\n",
              reinterpret_cast<unsigned int>(code->address()),
              reinterpret_cast<unsigned int>(assem));
   msg.WriteToLogFile();
 #endif
 }
@@ skipping 232 matching lines @@
               // All other %'s expand to themselves.
               stream.Put('%');
               stream.Put(*p);
               break;
           }
         } else {
           stream.Put(*p);
         }
       }
       SmartPointer<const char> expanded = stream.ToCString();
-      logfile_ = OS::FOpen(*expanded, "w");
+      logfile_ = OS::FOpen(*expanded, OS::LogFileOpenMode);
     } else {
-      logfile_ = OS::FOpen(FLAG_logfile, "w");
+      logfile_ = OS::FOpen(FLAG_logfile, OS::LogFileOpenMode);
     }
     message_buffer_ = NewArray<char>(kMessageBufferSize);
     mutex_ = OS::CreateMutex();
   }
 
   current_state_ = &bottom_state_;
 
   // as log is initialized early with V8, we can assume that JS execution
   // frames can never reach this point on stack
   int stack_var;
@@ skipping 136 matching lines @@
     } else if (previous_->state_ == EXTERNAL) {
       // We are leaving V8.
       Heap::Protect();
     }
   }
 #endif
 }
 #endif
 
 } }  // namespace v8::internal