Move platform abstraction to base library

src/log.cc

 // Copyright 2011 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 <stdarg.h>
 
 #include "src/v8.h"
 
+#include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/cpu-profiler.h"
 #include "src/deoptimizer.h"
 #include "src/global-handles.h"
 #include "src/log.h"
 #include "src/log-utils.h"
 #include "src/macro-assembler.h"
-#include "src/platform.h"
 #include "src/runtime-profiler.h"
 #include "src/serialize.h"
 #include "src/string-stream.h"
 #include "src/vm-state-inl.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define DECLARE_EVENT(ignore1, name) name,
@@ skipping 227 matching lines @@
 const int PerfBasicLogger::kFilenameBufferPadding = 16;
 
 PerfBasicLogger::PerfBasicLogger()
     : perf_output_handle_(NULL) {
   // Open the perf JIT dump file.
   int bufferSize = sizeof(kFilenameFormatString) + kFilenameBufferPadding;
   ScopedVector<char> perf_dump_name(bufferSize);
   int size = SNPrintF(
       perf_dump_name,
       kFilenameFormatString,
-      OS::GetCurrentProcessId());
+      base::OS::GetCurrentProcessId());
   CHECK_NE(size, -1);
-  perf_output_handle_ = OS::FOpen(perf_dump_name.start(), OS::LogFileOpenMode);
+  perf_output_handle_ =
+      base::OS::FOpen(perf_dump_name.start(), base::OS::LogFileOpenMode);
   CHECK_NE(perf_output_handle_, NULL);
   setvbuf(perf_output_handle_, NULL, _IOFBF, kLogBufferSize);
 }
 
 
 PerfBasicLogger::~PerfBasicLogger() {
   fclose(perf_output_handle_);
   perf_output_handle_ = NULL;
 }
 
 
 void PerfBasicLogger::LogRecordedBuffer(Code* code,
                                        SharedFunctionInfo*,
                                        const char* name,
                                        int length) {
   ASSERT(code->instruction_start() == code->address() + Code::kHeaderSize);
 
-  OS::FPrint(perf_output_handle_, "%llx %x %.*s\n",
-      reinterpret_cast<uint64_t>(code->instruction_start()),
-      code->instruction_size(),
-      length, name);
+  base::OS::FPrint(perf_output_handle_, "%llx %x %.*s\n",
+                   reinterpret_cast<uint64_t>(code->instruction_start()),
+                   code->instruction_size(), length, name);
 }
 
 
 // Linux perf tool logging support
 class PerfJitLogger : public CodeEventLogger {
  public:
   PerfJitLogger();
   virtual ~PerfJitLogger();
 
   virtual void CodeMoveEvent(Address from, Address to) { }
@@ skipping 80 matching lines @@
 const int PerfJitLogger::kFilenameBufferPadding = 16;
 
 PerfJitLogger::PerfJitLogger()
     : perf_output_handle_(NULL) {
   // Open the perf JIT dump file.
   int bufferSize = sizeof(kFilenameFormatString) + kFilenameBufferPadding;
   ScopedVector<char> perf_dump_name(bufferSize);
   int size = SNPrintF(
       perf_dump_name,
       kFilenameFormatString,
-      OS::GetCurrentProcessId());
+      base::OS::GetCurrentProcessId());
   CHECK_NE(size, -1);
-  perf_output_handle_ = OS::FOpen(perf_dump_name.start(), OS::LogFileOpenMode);
+  perf_output_handle_ =
+      base::OS::FOpen(perf_dump_name.start(), base::OS::LogFileOpenMode);
   CHECK_NE(perf_output_handle_, NULL);
   setvbuf(perf_output_handle_, NULL, _IOFBF, kLogBufferSize);
 
   LogWriteHeader();
 }
 
 
 PerfJitLogger::~PerfJitLogger() {
   fclose(perf_output_handle_);
   perf_output_handle_ = NULL;
@@ skipping 10 matching lines @@
   const char* code_name = name;
   uint8_t* code_pointer = reinterpret_cast<uint8_t*>(code->instruction_start());
   uint32_t code_size = code->instruction_size();
 
   static const char string_terminator[] = "\0";
 
   jr_code_load code_load;
   code_load.id = JIT_CODE_LOAD;
   code_load.total_size = sizeof(code_load) + length + 1 + code_size;
   code_load.timestamp =
-      static_cast<uint64_t>(OS::TimeCurrentMillis() * 1000.0);
+      static_cast<uint64_t>(base::OS::TimeCurrentMillis() * 1000.0);
   code_load.vma = 0x0;  //  Our addresses are absolute.
   code_load.code_addr = reinterpret_cast<uint64_t>(code->instruction_start());
   code_load.code_size = code_size;
   code_load.align = 0;
 
   LogWriteBytes(reinterpret_cast<const char*>(&code_load), sizeof(code_load));
   LogWriteBytes(code_name, length);
   LogWriteBytes(string_terminator, 1);
   LogWriteBytes(reinterpret_cast<const char*>(code_pointer), code_size);
 }
 
 
 void PerfJitLogger::LogWriteBytes(const char* bytes, int size) {
   size_t rv = fwrite(bytes, 1, size, perf_output_handle_);
   ASSERT(static_cast<size_t>(size) == rv);
   USE(rv);
 }
 
 
 void PerfJitLogger::LogWriteHeader() {
   ASSERT(perf_output_handle_ != NULL);
   jitheader header;
   header.magic = kJitHeaderMagic;
   header.version = kJitHeaderVersion;
   header.total_size = sizeof(jitheader);
   header.pad1 = 0xdeadbeef;
   header.elf_mach = GetElfMach();
-  header.pid = OS::GetCurrentProcessId();
-  header.timestamp = static_cast<uint64_t>(OS::TimeCurrentMillis() * 1000.0);
+  header.pid = base::OS::GetCurrentProcessId();
+  header.timestamp =
+      static_cast<uint64_t>(base::OS::TimeCurrentMillis() * 1000.0);
   LogWriteBytes(reinterpret_cast<const char*>(&header), sizeof(header));
 }
 
 
 // Low-level logging support.
 #define LL_LOG(Call) if (ll_logger_) ll_logger_->Call;
 
 class LowLevelLogger : public CodeEventLogger {
  public:
   explicit LowLevelLogger(const char* file_name);
@@ skipping 69 matching lines @@
 
 const char LowLevelLogger::kLogExt[] = ".ll";
 
 LowLevelLogger::LowLevelLogger(const char* name)
     : ll_output_handle_(NULL) {
   // Open the low-level log file.
   size_t len = strlen(name);
   ScopedVector<char> ll_name(static_cast<int>(len + sizeof(kLogExt)));
   MemCopy(ll_name.start(), name, len);
   MemCopy(ll_name.start() + len, kLogExt, sizeof(kLogExt));
-  ll_output_handle_ = OS::FOpen(ll_name.start(), OS::LogFileOpenMode);
+  ll_output_handle_ =
+      base::OS::FOpen(ll_name.start(), base::OS::LogFileOpenMode);
   setvbuf(ll_output_handle_, NULL, _IOFBF, kLogBufferSize);
 
   LogCodeInfo();
 }
 
 
 LowLevelLogger::~LowLevelLogger() {
   fclose(ll_output_handle_);
   ll_output_handle_ = NULL;
 }
@@ skipping 196 matching lines @@
 
   code_event_handler_(&event);
 }
 
 
 // The Profiler samples pc and sp values for the main thread.
 // Each sample is appended to a circular buffer.
 // An independent thread removes data and writes it to the log.
 // This design minimizes the time spent in the sampler.
 //
-class Profiler: public Thread {
+class Profiler: public base::Thread {
  public:
   explicit Profiler(Isolate* isolate);
   void Engage();
   void Disengage();
 
   // Inserts collected profiling data into buffer.
   void Insert(TickSample* sample) {
     if (paused_)
       return;
 
@@ skipping 28 matching lines @@
 
   Isolate* isolate_;
   // Cyclic buffer for communicating profiling samples
   // between the signal handler and the worker thread.
   static const int kBufferSize = 128;
   TickSample buffer_[kBufferSize];  // Buffer storage.
   int head_;  // Index to the buffer head.
   int tail_;  // Index to the buffer tail.
   bool overflow_;  // Tell whether a buffer overflow has occurred.
   // Sempahore used for buffer synchronization.
-  Semaphore buffer_semaphore_;
+  base::Semaphore buffer_semaphore_;
 
   // Tells whether profiler is engaged, that is, processing thread is stated.
   bool engaged_;
 
   // Tells whether worker thread should continue running.
   bool running_;
 
   // Tells whether we are currently recording tick samples.
   bool paused_;
 };
@@ skipping 30 matching lines @@
 
  private:
   Profiler* profiler_;
 };
 
 
 //
 // Profiler implementation.
 //
 Profiler::Profiler(Isolate* isolate)
-    : Thread("v8:Profiler"),
+    : base::Thread("v8:Profiler"),
       isolate_(isolate),
       head_(0),
       tail_(0),
       overflow_(false),
       buffer_semaphore_(0),
       engaged_(false),
       running_(false),
       paused_(false) {
 }
 
 
 void Profiler::Engage() {
   if (engaged_) return;
   engaged_ = true;
 
-  std::vector<OS::SharedLibraryAddress> addresses =
-      OS::GetSharedLibraryAddresses();
+  std::vector<base::OS::SharedLibraryAddress> addresses =
+      base::OS::GetSharedLibraryAddresses();
   for (size_t i = 0; i < addresses.size(); ++i) {
     LOG(isolate_, SharedLibraryEvent(
         addresses[i].library_path, addresses[i].start, addresses[i].end));
   }
 
   // Start thread processing the profiler buffer.
   running_ = true;
   Start();
 
   // Register to get ticks.
@@ skipping 593 matching lines @@
   msg.WriteToLogFile();
 }
 
 
 void Logger::CodeMovingGCEvent() {
   PROFILER_LOG(CodeMovingGCEvent());
 
   if (!is_logging_code_events()) return;
   if (!log_->IsEnabled() || !FLAG_ll_prof) return;
   CALL_LISTENERS(CodeMovingGCEvent());
-  OS::SignalCodeMovingGC();
+  base::OS::SignalCodeMovingGC();
 }
 
 
 void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
   PROFILER_LOG(RegExpCodeCreateEvent(code, source));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(RegExpCodeCreateEvent(code, source));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
@@ skipping 108 matching lines @@
   msg.WriteToLogFile();
 }
 
 
 void Logger::ResourceEvent(const char* name, const char* tag) {
   if (!log_->IsEnabled() || !FLAG_log) return;
   Log::MessageBuilder msg(log_);
   msg.Append("%s,%s,", name, tag);
 
   uint32_t sec, usec;
-  if (OS::GetUserTime(&sec, &usec) != -1) {
+  if (base::OS::GetUserTime(&sec, &usec) != -1) {
     msg.Append("%d,%d,", sec, usec);
   }
-  msg.Append("%.0f", OS::TimeCurrentMillis());
+  msg.Append("%.0f", base::OS::TimeCurrentMillis());
 
   msg.Append('\n');
   msg.WriteToLogFile();
 }
 
 
 void Logger::SuspectReadEvent(Name* name, Object* obj) {
   if (!log_->IsEnabled() || !FLAG_log_suspect) return;
   Log::MessageBuilder msg(log_);
   String* class_name = obj->IsJSObject()
@@ skipping 13 matching lines @@
   msg.WriteToLogFile();
 }
 
 
 void Logger::HeapSampleBeginEvent(const char* space, const char* kind) {
   if (!log_->IsEnabled() || !FLAG_log_gc) return;
   Log::MessageBuilder msg(log_);
   // Using non-relative system time in order to be able to synchronize with
   // external memory profiling events (e.g. DOM memory size).
   msg.Append("heap-sample-begin,\"%s\",\"%s\",%.0f\n",
-             space, kind, OS::TimeCurrentMillis());
+             space, kind, base::OS::TimeCurrentMillis());
   msg.WriteToLogFile();
 }
 
 
 void Logger::HeapSampleEndEvent(const char* space, const char* kind) {
   if (!log_->IsEnabled() || !FLAG_log_gc) return;
   Log::MessageBuilder msg(log_);
   msg.Append("heap-sample-end,\"%s\",\"%s\"\n", space, kind);
   msg.WriteToLogFile();
 }
@@ skipping 18 matching lines @@
 void Logger::DebugEvent(const char* event_type, Vector<uint16_t> parameter) {
   if (!log_->IsEnabled() || !FLAG_log) return;
   StringBuilder s(parameter.length() + 1);
   for (int i = 0; i < parameter.length(); ++i) {
     s.AddCharacter(static_cast<char>(parameter[i]));
   }
   char* parameter_string = s.Finalize();
   Log::MessageBuilder msg(log_);
   msg.Append("debug-queue-event,%s,%15.3f,%s\n",
              event_type,
-             OS::TimeCurrentMillis(),
+             base::OS::TimeCurrentMillis(),
              parameter_string);
   DeleteArray(parameter_string);
   msg.WriteToLogFile();
 }
 
 
 void Logger::TickEvent(TickSample* sample, bool overflow) {
   if (!log_->IsEnabled() || !FLAG_prof) return;
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[TICK_EVENT]);
@@ skipping 277 matching lines @@
   for (const char* p = file_name; *p; p++) {
     if (*p == '%') {
       p++;
       switch (*p) {
         case '\0':
           // If there's a % at the end of the string we back up
           // one character so we can escape the loop properly.
           p--;
           break;
         case 'p':
-          stream.Add("%d", OS::GetCurrentProcessId());
+          stream.Add("%d", base::OS::GetCurrentProcessId());
           break;
         case 't': {
           // %t expands to the current time in milliseconds.
-          double time = OS::TimeCurrentMillis();
+          double time = base::OS::TimeCurrentMillis();
           stream.Add("%.0f", FmtElm(time));
           break;
         }
         case '%':
           // %% expands (contracts really) to %.
           stream.Put('%');
           break;
         default:
           // All other %'s expand to themselves.
           stream.Put('%');
@@ skipping 116 matching lines @@
   if (jit_logger_) {
     removeCodeEventListener(jit_logger_);
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
   return log_->Close();
 }
 
 } }  // namespace v8::internal