[Interpreter] Make ignition compiler eagerly.

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 "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
@@ skipping 1258 matching lines @@
       // functions, so do not parse lazily in that case.
       ScriptCompiler::CompileOptions options = parse_info->compile_options();
       bool parse_allow_lazy = (options == ScriptCompiler::kConsumeParserCache ||
                                String::cast(script->source())->length() >
                                    FLAG_min_preparse_length) &&
                               !info->is_debug();
 
       // Consider parsing eagerly when targeting the code cache.
       parse_allow_lazy &= !(FLAG_serialize_eager && info->will_serialize());
 
+      // Consider parsing eagerly when targeting Ignition.
+      parse_allow_lazy &= !(FLAG_ignition && !isolate->serializer_enabled());

[Yang, 2016/03/23 14:29:11]

Not sure whether we need the serializer_enabled part. I don't think there is a
difference since we throw away bytecode arrays on serialization anyways. But
maybe we will change that in the future and include bytecode  arrays in the
snapshot.

[rmcilroy, 2016/03/24 11:30:45]

Yeah, the issue here is that if we eagerly compile the snapshot, we eagerly
compile the builtin functions before they are assigned builtin-ids, which means
we can't blacklist the generator related builtins (which don't compile in
ignition - see UseIgnition()).

+
       parse_info->set_allow_lazy_parsing(parse_allow_lazy);
       if (!parse_allow_lazy &&
           (options == ScriptCompiler::kProduceParserCache ||
            options == ScriptCompiler::kConsumeParserCache)) {
         // We are going to parse eagerly, but we either 1) have cached data
         // produced by lazy parsing or 2) are asked to generate cached data.
         // Eager parsing cannot benefit from cached data, and producing cached
         // data while parsing eagerly is not implemented.
         parse_info->set_cached_data(nullptr);
         parse_info->set_compile_options(ScriptCompiler::kNoCompileOptions);
@@ skipping 495 matching lines @@
   // unless we can lazily compile without the context.
   bool allow_lazy = literal->AllowsLazyCompilation() &&
                     !LiveEditFunctionTracker::IsActive(isolate) &&
                     (!info.is_debug() || allow_lazy_without_ctx);
 
   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 && !isolate->serializer_enabled());
+
   // Generate code
   TimerEventScope<TimerEventCompileCode> timer(isolate);
   TRACE_EVENT0("v8", "V8.CompileCode");
   if (lazy) {
     info.SetCode(isolate->builtins()->CompileLazy());
   } else if (Renumber(info.parse_info()) && GenerateBaselineCode(&info)) {
     // Code generation will ensure that the feedback vector is present and
     // appropriately sized.
     DCHECK(!info.code().is_null());
     Handle<ScopeInfo> scope_info =
@@ skipping 149 matching lines @@
     MaybeHandle<Code> code;
     if (cached.code != nullptr) code = handle(cached.code);
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                               literals, BailoutId::None());
   }
 }
 
 }  // namespace internal
 }  // namespace v8