Teach Scopes whether they will end up being lazily compiled or not

src/compiler.cc

 // Copyright 2012 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 "src/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 1413 matching lines @@
       InstallSharedScopeInfo(info, shared);
     }
 
     // Install compilation result on the shared function info
     shared->EnableDeoptimizationSupport(*unoptimized.code());
 
     // The existing unoptimized code was replaced with the new one.
     RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG,
                               &unoptimized);
   }
+  info->parse_info()->set_will_serialize(false);

[marja, 2016/10/07 08:25:59]

Comment suggestion:

We reuse the same ParseInfo in the future, and might have set_will_serialize in
EnableDeoptimizationSupport, so reset it here.

[jochen (gone - plz use gerrit), 2016/10/07 08:34:37]

I moved the code it but further up and added a comment

   return true;
 }
 
 // static
 Compiler::CompilationTier Compiler::NextCompilationTier(JSFunction* function) {
   Handle<SharedFunctionInfo> shared(function->shared(), function->GetIsolate());
   if (shared->code()->is_interpreter_trampoline_builtin()) {
     if (FLAG_turbo_from_bytecode && UseTurboFan(shared)) {
       return OPTIMIZED;
     } else {
@@ skipping 324 matching lines @@
 
   Zone zone(isolate->allocator());
   ParseInfo parse_info(&zone, script);
   CompilationInfo info(&parse_info, Handle<JSFunction>::null());
   parse_info.set_literal(literal);
   parse_info.set_shared_info(result);
   parse_info.set_language_mode(literal->scope()->language_mode());
   if (outer_info->will_serialize()) info.PrepareForSerializing();
   if (outer_info->is_debug()) info.MarkAsDebug();
 
-  // Determine if the function can be lazily compiled. This is necessary to
-  // allow some of our builtin JS files to be lazily compiled. These
-  // builtins cannot be handled lazily by the parser, since we have to know
-  // if a function uses the special natives syntax, which is something the
-  // parser records.
-  // If the debugger requests compilation for break points, we cannot be
-  // aggressive about lazy compilation, because it might trigger compilation
-  // of functions without an outer context when setting a breakpoint through
-  // Debug::FindSharedFunctionInfoInScript.
-  bool allow_lazy = literal->AllowsLazyCompilation() && !info.is_debug();
-  bool lazy = FLAG_lazy && allow_lazy && !literal->should_eager_compile();
-
-  // Consider compiling eagerly when targeting the code cache.
-  lazy &= !(FLAG_serialize_eager && info.will_serialize());
-
-  // Consider compiling eagerly when compiling bytecode for Ignition.
-  lazy &=
-      !(FLAG_ignition && FLAG_ignition_eager && !isolate->serializer_enabled());
-
   // Generate code
   TimerEventScope<TimerEventCompileCode> timer(isolate);
   RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::CompileCode);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileCode");
 
-  if (lazy) {
+  if (!literal->ShouldEagerCompile()) {
     info.SetCode(isolate->builtins()->CompileLazy());
     Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
     if (outer_scope) {
       result->set_outer_scope_info(*outer_scope->scope_info());
     }
   } else if (Renumber(info.parse_info()) && GenerateUnoptimizedCode(&info)) {
     // Code generation will ensure that the feedback vector is present and
     // appropriately sized.
     DCHECK(!info.code().is_null());
-    if (literal->should_eager_compile() &&
-        literal->should_be_used_once_hint()) {
+    if (literal->ShouldEagerCompile() && literal->should_be_used_once_hint()) {

[marja, 2016/10/07 08:25:59]

Wait, isn't this always true now, since we are in the "else" branch of "if
(!literal->ShouldEagerCompile())"?

Also I think here you change the behavior and I cannot tell if it's correct or
not.

So previously we would only MarkToBeExecutedOnce if the reason for eagerly
compiling was literal->should_eager_compile(), so, it was not enough that !lazy.

But now you're collapsing both kind of conditions into one, so you cannot here
differentiate between different reasons for eagerly compiling.

But if it works, fair enough. :) It might be that the previous code was overly
cautious about not calling MarkToBeExecutedOnce unnecessarily.

[jochen (gone - plz use gerrit), 2016/10/07 08:34:37]

I removed the ShouldEagerCompilePart()

       info.code()->MarkToBeExecutedOnce(isolate);
     }
     // Update the shared function info with the scope info.
     InstallSharedScopeInfo(&info, result);
     // Install compilation result on the shared function info.
     InstallSharedCompilationResult(&info, result);
   } else {
     return Handle<SharedFunctionInfo>::null();
   }
 
@@ skipping 89 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8