[v8-dev] Move global V8::UseCrankshaft() into the Isolate. (issue 23441029)

mstarzinger Mon, 02 Sep 2013 08:08:59 -0700

Reviewers: Jakob,

Description:
Move global V8::UseCrankshaft() into the Isolate.


[email protected]
BUG=v8:2744

Please review this at https://codereview.chromium.org/23441029/

SVN Base: https://v8.googlecode.com/svn/branches/bleeding_edge

Affected files:
  M src/compiler.h
  M src/compiler.cc
  M src/factory.cc
  M src/isolate.h
  M src/isolate.cc
  M src/runtime.cc
  M src/v8.h
  M src/v8.cc
  M test/cctest/test-deoptimization.cc
  M test/cctest/test-heap.cc
  M test/cctest/test-random.cc


Index: src/compiler.cc
diff --git a/src/compiler.cc b/src/compiler.cc

index1fba20fa5b923790d9ac720a69f68f2da952157c..1d995e9493c0f634a1576407499b44afc6a12211100644

--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -119,7 +119,7 @@ void CompilationInfo::Initialize(Isolate* isolate,
     mode_ = STUB;
     return;
   }
-  mode_ = V8::UseCrankshaft() ? mode : NONOPT;
+  mode_ = isolate->use_crankshaft() ? mode : NONOPT;
   abort_due_to_dependency_ = false;
   if (script_->type()->value() == Script::TYPE_NATIVE) {
     MarkAsNative();
@@ -242,7 +242,7 @@ bool CompilationInfo::ShouldSelfOptimize() {
 // break points has actually been set.
 static bool IsDebuggerActive(Isolate* isolate) {
 #ifdef ENABLE_DEBUGGER_SUPPORT
-  return V8::UseCrankshaft() ?
+  return isolate->use_crankshaft() ?
     isolate->debug()->has_break_points() :
     isolate->debugger()->IsDebuggerActive();
 #else
@@ -310,7 +310,7 @@ static bool MakeCrankshaftCode(CompilationInfo* info) {


 OptimizingCompiler::Status OptimizingCompiler::CreateGraph() {
-  ASSERT(V8::UseCrankshaft());
+  ASSERT(isolate()->use_crankshaft());
   ASSERT(info()->IsOptimizing());
   ASSERT(!info()->IsCompilingForDebugging());

@@ -499,7 +499,7 @@ OptimizingCompiler::StatusOptimizingCompiler::GenerateAndInstallCode() {



 static bool GenerateCode(CompilationInfo* info) {
-  bool is_optimizing = V8::UseCrankshaft() &&
+  bool is_optimizing = info->isolate()->use_crankshaft() &&
                        !info->IsCompilingForDebugging() &&
                        info->IsOptimizing();
   if (is_optimizing) {
@@ -838,7 +838,7 @@ static bool InstallFullCode(CompilationInfo* info) {
   shared->set_dont_inline(lit->flags()->Contains(kDontInline));
   shared->set_ast_node_count(lit->ast_node_count());

-  if (V8::UseCrankshaft() &&
+  if (info->isolate()->use_crankshaft() &&
       !function.is_null() &&
       !shared->optimization_disabled()) {
     // If we're asked to always optimize, we compile the optimized
Index: src/compiler.h
diff --git a/src/compiler.h b/src/compiler.h

indexbdb168fe0d107a397a724bded304902be20a8774..4f6a47244cfe20383bab5a4c48b9d0bb6f6dafda100644

--- a/src/compiler.h
+++ b/src/compiler.h
@@ -335,7 +335,7 @@ class CompilationInfo {
   void Initialize(Isolate* isolate, Mode mode, Zone* zone);

   void SetMode(Mode mode) {
-    ASSERT(V8::UseCrankshaft());
+    ASSERT(isolate()->use_crankshaft());
     mode_ = mode;
   }

Index: src/factory.cc
diff --git a/src/factory.cc b/src/factory.cc

indexbd6ed2bc89c1910de884e4d0e80367b60aa9af97..74d42e4e82703ce2739d3e9c055be7ffcc613827100644

--- a/src/factory.cc
+++ b/src/factory.cc

@@ -664,7 +664,7 @@ Handle<JSFunction>Factory::NewFunctionFromSharedFunctionInfo(

     return result;
   }

-  if (V8::UseCrankshaft() &&
+  if (isolate()->use_crankshaft() &&
       FLAG_always_opt &&
       result->is_compiled() &&
       !function_info->is_toplevel() &&
Index: src/isolate.cc
diff --git a/src/isolate.cc b/src/isolate.cc

index0e7b6d55d1521965efb3c4b7a04974e66c19d3cd..bcccae498411394604611ccc8879ea3c4b319c53100644

--- a/src/isolate.cc
+++ b/src/isolate.cc
@@ -1792,6 +1792,7 @@ Isolate::Isolate()
       regexp_stack_(NULL),
       date_cache_(NULL),
       code_stub_interface_descriptors_(NULL),
+      use_crankshaft_(true),
       initialized_from_snapshot_(false),
       cpu_profiler_(NULL),
       heap_profiler_(NULL),
@@ -2147,6 +2148,10 @@ bool Isolate::Init(Deserializer* des) {

   stress_deopt_count_ = FLAG_deopt_every_n_times;

+  use_crankshaft_ = FLAG_crankshaft
+      && !Serializer::enabled()
+      && CPU::SupportsCrankshaft();
+
   if (function_entry_hook() != NULL) {
     // When function entry hooking is in effect, we have to create the code

// stubs from scratch to get entry hooks, rather than loading thepreviously

Index: src/isolate.h
diff --git a/src/isolate.h b/src/isolate.h

index8eace1268481c1011607548a610c37f1a31625f6..9220a6a93d6718889add651968ecc712c6a54737100644

--- a/src/isolate.h
+++ b/src/isolate.h
@@ -1059,6 +1059,8 @@ class Isolate {
     thread_local_top_.top_lookup_result_ = top;
   }

+  bool use_crankshaft() { return use_crankshaft_; }
+
   bool initialized_from_snapshot() { return initialized_from_snapshot_; }

   double time_millis_since_init() {
@@ -1300,6 +1302,9 @@ class Isolate {

unibrow::Mapping<unibrow::Ecma262Canonicalize>interp_canonicalize_mapping_;

   CodeStubInterfaceDescriptor* code_stub_interface_descriptors_;

+  // True if we are using the Crankshaft optimizing compiler.
+  bool use_crankshaft_;
+
   // True if this isolate was initialized from a snapshot.
   bool initialized_from_snapshot_;

Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc

index4830fafe35c323598e0bd6a49ed6f7a7ef6569ca..174fbdd7e6ebcd3834de0bc8b2c954694999b973100644

--- a/src/runtime.cc
+++ b/src/runtime.cc

@@ -8346,7 +8346,7 @@ RUNTIME_FUNCTION(MaybeObject*,Runtime_InstallRecompiledCode) {

   HandleScope handle_scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
-  ASSERT(V8::UseCrankshaft() && FLAG_concurrent_recompilation);
+  ASSERT(isolate->use_crankshaft() && FLAG_concurrent_recompilation);
   isolate->optimizing_compiler_thread()->InstallOptimizedFunctions();
   return function->code();
 }

@@ -8532,7 +8532,7 @@ RUNTIME_FUNCTION(MaybeObject*,Runtime_NeverOptimizeFunction) {

 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetOptimizationStatus) {
   HandleScope scope(isolate);
   RUNTIME_ASSERT(args.length() == 1 || args.length() == 2);
-  if (!V8::UseCrankshaft()) {
+  if (!isolate->use_crankshaft()) {
     return Smi::FromInt(4);  // 4 == "never".
   }
   bool sync_with_compiler_thread = true;
Index: src/v8.cc
diff --git a/src/v8.cc b/src/v8.cc

index7d2294ee0cf1ba6b4d19acccabac4bce04e6558c..31d2dd579d66e880dd294b0d45efd8903cb7c701100644

--- a/src/v8.cc
+++ b/src/v8.cc
@@ -54,7 +54,6 @@ bool V8::is_running_ = false;
 bool V8::has_been_set_up_ = false;
 bool V8::has_been_disposed_ = false;
 bool V8::has_fatal_error_ = false;
-bool V8::use_crankshaft_ = true;
 List<CallCompletedCallback>* V8::call_completed_callbacks_ = NULL;
 v8::ArrayBuffer::Allocator* V8::array_buffer_allocator_ = NULL;

@@ -318,9 +317,6 @@ void V8::InitializeOncePerProcessImpl() {
   OS::SetUp();
   Sampler::SetUp();
   CPU::SetUp();
-  use_crankshaft_ = FLAG_crankshaft
-      && !Serializer::enabled()
-      && CPU::SupportsCrankshaft();
   OS::PostSetUp();
   ElementsAccessor::InitializeOncePerProcess();
   LOperand::SetUpCaches();
Index: src/v8.h
diff --git a/src/v8.h b/src/v8.h

index47893e8215e443a2f05d366001dc8a855b9476f6..aee4890aa066a9a949346d522b3106174fba9ae3100644

--- a/src/v8.h
+++ b/src/v8.h
@@ -83,7 +83,6 @@ class V8 : public AllStatic {
   static bool Initialize(Deserializer* des);
   static void TearDown();
   static bool IsRunning() { return is_running_; }
-  static bool UseCrankshaft() { return use_crankshaft_; }
   // To be dead you have to have lived
   // TODO(isolates): move IsDead to Isolate.
   static bool IsDead() { return has_fatal_error_ || has_been_disposed_; }
@@ -141,8 +140,6 @@ class V8 : public AllStatic {
   // True if engine has been shut down
   // (reset if engine is restarted)
   static bool has_been_disposed_;
-  // True if we are using the crankshaft optimizing compiler.
-  static bool use_crankshaft_;
   // List of callbacks when a Call completes.
   static List<CallCompletedCallback>* call_completed_callbacks_;
   // Allocator for external array buffers.
Index: test/cctest/test-deoptimization.cc

diff --git a/test/cctest/test-deoptimization.ccb/test/cctest/test-deoptimization.ccindex10fe99ca00dfe90b8552b1fd468a047a4426e9fd..83a6354b2fbbb6cace7a0fe17ae702aac2173990100644

--- a/test/cctest/test-deoptimization.cc
+++ b/test/cctest/test-deoptimization.cc
@@ -367,7 +367,7 @@ TEST(DeoptimizeBinaryOperationADDString) {
     i::FLAG_always_opt = true;
     CompileRun(f_source);
     CompileRun("f('a+', new X());");
-    CHECK(!i::V8::UseCrankshaft() ||
+    CHECK(!i::Isolate::Current()->use_crankshaft() ||
           GetJSFunction(env->Global(), "f")->IsOptimized());

// Call f and force deoptimization while processing the binaryoperation.@@ -419,7 +419,7 @@ static void TestDeoptimizeBinaryOpHelper(LocalContext*env,

   i::FLAG_always_opt = true;
   CompileRun(f_source);
   CompileRun("f(7, new X());");
-  CHECK(!i::V8::UseCrankshaft() ||
+  CHECK(!i::Isolate::Current()->use_crankshaft() ||
         GetJSFunction((*env)->Global(), "f")->IsOptimized());

   // Call f and force deoptimization while processing the binary operation.
@@ -517,7 +517,7 @@ TEST(DeoptimizeCompare) {
     i::FLAG_always_opt = true;
     CompileRun(f_source);
     CompileRun("f('a', new X());");
-    CHECK(!i::V8::UseCrankshaft() ||
+    CHECK(!i::Isolate::Current()->use_crankshaft() ||
           GetJSFunction(env->Global(), "f")->IsOptimized());

     // Call f and force deoptimization while processing the comparison.
@@ -587,7 +587,7 @@ TEST(DeoptimizeLoadICStoreIC) {
     CompileRun("g1(new X());");
     CompileRun("f2(new X(), 'z');");
     CompileRun("g2(new X(), 'z');");
-    if (i::V8::UseCrankshaft()) {
+    if (i::Isolate::Current()->use_crankshaft()) {
       CHECK(GetJSFunction(env->Global(), "f1")->IsOptimized());
       CHECK(GetJSFunction(env->Global(), "g1")->IsOptimized());
       CHECK(GetJSFunction(env->Global(), "f2")->IsOptimized());
@@ -671,7 +671,7 @@ TEST(DeoptimizeLoadICStoreICNested) {
     CompileRun("g1(new X());");
     CompileRun("f2(new X(), 'z');");
     CompileRun("g2(new X(), 'z');");
-    if (i::V8::UseCrankshaft()) {
+    if (i::Isolate::Current()->use_crankshaft()) {
       CHECK(GetJSFunction(env->Global(), "f1")->IsOptimized());
       CHECK(GetJSFunction(env->Global(), "g1")->IsOptimized());
       CHECK(GetJSFunction(env->Global(), "f2")->IsOptimized());
Index: test/cctest/test-heap.cc
diff --git a/test/cctest/test-heap.cc b/test/cctest/test-heap.cc

indexfc6a1ec40ff13a047aceb5d585f7b6a5c7f06217..fa7a70b63500aed506bfa1892a862b3d65b8f63a100644

--- a/test/cctest/test-heap.cc
+++ b/test/cctest/test-heap.cc
@@ -1332,7 +1332,7 @@ TEST(TestInternalWeakLists) {
     isolate->compilation_cache()->Clear();
     heap->CollectAllGarbage(Heap::kNoGCFlags);

-    bool opt = (FLAG_always_opt && i::V8::UseCrankshaft());
+    bool opt = (FLAG_always_opt && isolate->use_crankshaft());

     CHECK_EQ(i + 1, CountNativeContexts());

@@ -1476,7 +1476,7 @@ TEST(TestInternalWeakListsTraverseWithGC) {
     CHECK_EQ(i + 1, CountNativeContextsWithGC(isolate, i / 2 + 1));
   }

-  bool opt = (FLAG_always_opt && i::V8::UseCrankshaft());
+  bool opt = (FLAG_always_opt && isolate->use_crankshaft());

   // Compile a number of functions the length of the weak list of optimized
   // functions both with and without GCs while iterating the list.
@@ -1876,7 +1876,7 @@ TEST(InstanceOfStubWriteBarrier) {
 #endif

   CcTest::InitializeVM();
-  if (!i::V8::UseCrankshaft()) return;
+  if (!i::Isolate::Current()->use_crankshaft()) return;
   if (i::FLAG_force_marking_deque_overflows) return;
   v8::HandleScope outer_scope(v8::Isolate::GetCurrent());

@@ -1993,7 +1993,7 @@TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {

 #endif

   CcTest::InitializeVM();
-  if (!i::V8::UseCrankshaft()) return;
+  if (!i::Isolate::Current()->use_crankshaft()) return;
   v8::HandleScope outer_scope(v8::Isolate::GetCurrent());

   {
@@ -2050,7 +2050,7 @@ TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) {
 #endif

   CcTest::InitializeVM();
-  if (!i::V8::UseCrankshaft()) return;
+  if (!i::Isolate::Current()->use_crankshaft()) return;
   v8::HandleScope outer_scope(CcTest::isolate());

   {
@@ -2089,7 +2089,7 @@ TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) {
 TEST(OptimizedAllocationAlwaysInNewSpace) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
-  if (!i::V8::UseCrankshaft() || i::FLAG_always_opt) return;