VM initialization refactoring.

src/v8.cc

 // Copyright 2006-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 23 matching lines @@
 #include "heap-profiler.h"
 #include "hydrogen.h"
 #include "lithium-allocator.h"
 #include "log.h"
 #include "runtime-profiler.h"
 #include "serialize.h"
 
 namespace v8 {
 namespace internal {
 
+static Mutex* init_once_mutex = OS::CreateMutex();
+static bool init_once_called = false;
+
 bool V8::is_running_ = false;
 bool V8::has_been_setup_ = false;
 bool V8::has_been_disposed_ = false;
 bool V8::has_fatal_error_ = false;
 bool V8::use_crankshaft_ = true;
 
 
 bool V8::Initialize(Deserializer* des) {
+  InitializeOncePerProcess();
+
   // The current thread may not yet had entered an isolate to run.
   // Note the Isolate::Current() may be non-null because for various
   // initialization purposes an initializing thread may be assigned an isolate
   // but not actually enter it.
   if (i::Isolate::CurrentPerIsolateThreadData() == NULL) {
     i::Isolate::EnterDefaultIsolate();
   }
 
   ASSERT(i::Isolate::CurrentPerIsolateThreadData() != NULL);
   ASSERT(i::Isolate::CurrentPerIsolateThreadData()->thread_id() ==
          i::Thread::GetThreadLocalInt(i::Isolate::thread_id_key()));
   ASSERT(i::Isolate::CurrentPerIsolateThreadData()->isolate() ==
          i::Isolate::Current());
 
   if (IsDead()) return false;
 
   Isolate* isolate = Isolate::Current();
   if (isolate->IsInitialized()) return true;
 
-#if defined(V8_TARGET_ARCH_ARM) && !defined(USE_ARM_EABI)
-  use_crankshaft_ = false;
-#else
-  use_crankshaft_ = FLAG_crankshaft;
-#endif
-
-  // Peephole optimization might interfere with deoptimization.
-  FLAG_peephole_optimization = !use_crankshaft_;
-
   is_running_ = true;
   has_been_setup_ = true;
   has_fatal_error_ = false;
   has_been_disposed_ = false;
 
   return isolate->Init(des);
 }
 
 
 void V8::SetFatalError() {
@@ skipping 91 matching lines @@
   // by computing:
   // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
   const double binary_million = 1048576.0;
   r->double_value = binary_million;
   r->uint64_t_value |=  random_bits;
   r->double_value -= binary_million;
 
   return heap_number;
 }
 
+
+void V8::InitializeOncePerProcess() {
+  ScopedLock lock(init_once_mutex);
+  if (init_once_called) return;
+  init_once_called = true;
+
+  // Setup the platform OS support.
+  OS::Setup();
+
+#if defined(V8_TARGET_ARCH_ARM) && !defined(USE_ARM_EABI)
+  use_crankshaft_ = false;
+#else
+  use_crankshaft_ = FLAG_crankshaft;
+#endif
+
+  if (Serializer::enabled()) {
+    use_crankshaft_ = false;
+  }
+
+  CPU::Setup();
+  if (!CPU::SupportsCrankshaft()) {
+    use_crankshaft_ = false;
+  }
+
+  // Peephole optimization might interfere with deoptimization.

[Mads Ager (chromium), 2011/03/31 13:48:21]

This is fine. Maybe we should file a bug report on getting rid of peephole
optimizations. Now that crankshaft is the default we should just rip it out.

+  FLAG_peephole_optimization = !use_crankshaft_;
+}
+
 } }  // namespace v8::internal