[Interpreter] Make ignition compiler eagerly.

src/compiler.cc

Index: src/compiler.cc
diff --git a/src/compiler.cc b/src/compiler.cc
index ee8f72bc0af7e73e6b2f32b8d39c589e6364679f..1479b9953c6ed2df1b4c8b12db6d5e663dc6da3d 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -1276,6 +1276,9 @@ Handle<SharedFunctionInfo> CompileToplevel(CompilationInfo* info) {
       // 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 ||
@@ -1791,6 +1794,9 @@ Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfo(
   // 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");