Move BailoutReason and flags computation to post-pass

src/compiler.cc

Index: src/compiler.cc
diff --git a/src/compiler.cc b/src/compiler.cc
index fa8201bf54158f58eb3d9f154e0988a213826ca3..5b5cda7cd9feff69b87f64aa932cef19b9bb81cf 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -578,6 +578,14 @@ void SetExpectedNofPropertiesFromEstimate(Handle<SharedFunctionInfo> shared,
 }
 
 
+static void MaybeDisableOptimization(Handle<SharedFunctionInfo> shared_info,

[Sven Panne, 2014/10/29 09:12:55]

I think this should be folded into DisableOptimization, which should probably be
renamed then. Hmmm, SetBailoutReason makes sense, but we already have
set_bailout_reason in that class (with a getter DisableOptimizationReason,
*very* consistent naming :-P). OK, so my proposal would be:

   * Rename DisableOptimization to SetBailoutReason and include the kNoReason
handling there.

   * Rename set_bailout_reason to set_disable_optimization_reason and
DisableOptimizationReason to disable_optimization_reason.

[wingo, 2014/11/12 08:50:51]

So, I did the renames to {set_,}disable_optimization_reason then looked at
DisableOptimization.  Thing is, DisableOptimization does not just update flags
in the shared function info -- it also updates flags on the code object, and the
code object can change.  I think MaybeDisableOptimization is the probably the
right solution here.  For sanity I added an assert to DisableOptimization that
the reason was not kNoReason.  WDYT?

+                                     BailoutReason bailout_reason) {
+  if (bailout_reason != kNoReason) {
+    shared_info->DisableOptimization(bailout_reason);
+  }
+}
+
+
 // Sets the function info on a function.
 // The start_position points to the first '(' character after the function name
 // in the full script source. When counting characters in the script source the
@@ -604,7 +612,7 @@ static void SetFunctionInfo(Handle<SharedFunctionInfo> function_info,
   function_info->set_has_duplicate_parameters(lit->has_duplicate_parameters());
   function_info->set_ast_node_count(lit->ast_node_count());
   function_info->set_is_function(lit->is_function());
-  function_info->set_bailout_reason(lit->dont_optimize_reason());
+  MaybeDisableOptimization(function_info, lit->dont_optimize_reason());
   function_info->set_dont_cache(lit->flags()->Contains(kDontCache));
   function_info->set_kind(lit->kind());
   function_info->set_asm_function(lit->scope()->asm_function());
@@ -668,7 +676,7 @@ MUST_USE_RESULT static MaybeHandle<Code> GetUnoptimizedCodeCommon(
   FunctionLiteral* lit = info->function();
   shared->set_strict_mode(lit->strict_mode());
   SetExpectedNofPropertiesFromEstimate(shared, lit->expected_property_count());
-  shared->set_bailout_reason(lit->dont_optimize_reason());
+  MaybeDisableOptimization(shared, lit->dont_optimize_reason());
 
   // Compile unoptimized code.
   if (!CompileUnoptimizedCode(info)) return MaybeHandle<Code>();
@@ -741,7 +749,10 @@ static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
 static bool Renumber(CompilationInfo* info) {
   if (!AstNumbering::Renumber(info->function(), info->zone())) return false;
   if (!info->shared_info().is_null()) {
-    info->shared_info()->set_ast_node_count(info->function()->ast_node_count());
+    FunctionLiteral* lit = info->function();
+    info->shared_info()->set_ast_node_count(lit->ast_node_count());
+    MaybeDisableOptimization(info->shared_info(), lit->dont_optimize_reason());
+    info->shared_info()->set_dont_cache(lit->flags()->Contains(kDontCache));
   }
   return true;
 }