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/06 11:53:06]

Why is this needed, shouldn't there be a default that we're not going to
serialize?

[jochen (gone - plz use gerrit), 2016/10/06 15:05:04]

In EnsureDeoptimizationSupport we might recompile the unoptimized code. For
this, we might have to enable the serializer.

The CompilationInfo "unoptimized", however, uses the same ParseInfo as the
optimized job will use, so I have to reset that flag now that it lives on
ParseInfo and no longer on CompilationInfo.

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

Offline discussion: this code for resetting the flag is actually conceptually
close to the place where the flag will potentially be set, but it's hard to see
since the setting is potentially done in EnableDeoptimizationSupport.

Maybe add 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 343 matching lines @@
   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());
 
+  DCHECK_EQ(lazy, literal->scope()->should_compile_lazily());
+
   // Generate code
   TimerEventScope<TimerEventCompileCode> timer(isolate);
   RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::CompileCode);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileCode");
 
   if (lazy) {
     info.SetCode(isolate->builtins()->CompileLazy());
     Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
     if (outer_scope) {
       result->set_outer_scope_info(*outer_scope->scope_info());
@@ skipping 106 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