[Compiler] Have renumber recurse into eagerly compiled function literals.

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 437 matching lines @@
     if (info->parse_info()->literal()->should_be_used_once_hint()) {
       info->code()->MarkToBeExecutedOnce(info->isolate());
     }
     InstallUnoptimizedCode(info);
     RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, info);
     job->RecordUnoptimizedCompilationStats();
   }
   return status;
 }
 
+void SetSharedFunctionFlagsFromLiteral(FunctionLiteral* literal,
+                                       Handle<SharedFunctionInfo> shared_info) {
+  shared_info->set_ast_node_count(literal->ast_node_count());
+  if (literal->dont_optimize_reason() != kNoReason) {
+    shared_info->DisableOptimization(literal->dont_optimize_reason());
+  }
+  if (literal->flags() & AstProperties::kMustUseIgnitionTurbo) {
+    shared_info->set_must_use_ignition_turbo(true);
+  }
+}
+
 bool Renumber(Isolate* isolate, Zone* zone, FunctionLiteral* literal,
               Handle<SharedFunctionInfo> shared_info,
               Compiler::EagerInnerFunctionLiterals* eager_literals) {
   RuntimeCallTimerScope runtimeTimer(isolate,
                                      &RuntimeCallStats::CompileRenumber);
   if (!AstNumbering::Renumber(isolate->stack_guard()->real_climit(), zone,
                               literal, eager_literals)) {
     return false;
   }
+
   if (!shared_info.is_null()) {
-    shared_info->set_ast_node_count(literal->ast_node_count());
-    if (literal->dont_optimize_reason() != kNoReason) {
-      shared_info->DisableOptimization(literal->dont_optimize_reason());
-    }
-    if (literal->flags() & AstProperties::kMustUseIgnitionTurbo) {
-      shared_info->set_must_use_ignition_turbo(true);
-    }
+    SetSharedFunctionFlagsFromLiteral(literal, shared_info);
   }
   return true;
 }
 
 bool GenerateUnoptimizedCode(CompilationInfo* info) {
   if (UseAsmWasm(info->scope(), info->shared_info(), info->is_debug())) {
     EnsureFeedbackMetadata(info);
     MaybeHandle<FixedArray> wasm_data;
     wasm_data = AsmJs::CompileAsmViaWasm(info);
     if (!wasm_data.is_null()) {
       info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
       info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
       InstallUnoptimizedCode(info);
       return true;
     }
   }
 
   std::unique_ptr<CompilationJob> job(GetUnoptimizedCompilationJob(info));
   if (job->PrepareJob() != CompilationJob::SUCCEEDED) return false;
   if (job->ExecuteJob() != CompilationJob::SUCCEEDED) return false;
   if (FinalizeUnoptimizedCompilationJob(job.get()) !=
       CompilationJob::SUCCEEDED) {
     return false;
   }
   return true;
 }
 
-bool CompileUnoptimizedInnerFunctionsRecursively(
+bool CompileUnoptimizedInnerFunctions(
     ThreadedList<ThreadedListZoneEntry<FunctionLiteral*>>* literals,
     CompilationInfo* outer_info) {
   Isolate* isolate = outer_info->isolate();
   Handle<Script> script = outer_info->script();
   bool is_debug = outer_info->is_debug();
   bool will_serialize = outer_info->will_serialize();
   RuntimeCallTimerScope runtimeTimer(isolate,
                                      &RuntimeCallStats::CompileInnerFunction);
 
   for (auto it : *literals) {
     FunctionLiteral* literal = it->value();
     Handle<SharedFunctionInfo> shared =
         Compiler::GetSharedFunctionInfo(literal, script, outer_info);
     if (shared->is_compiled()) continue;
-    Compiler::EagerInnerFunctionLiterals inner_literals;
-    if (!Renumber(isolate, outer_info->zone(), literal, shared,
-                  &inner_literals) ||
-        !CompileUnoptimizedInnerFunctionsRecursively(&inner_literals,
-                                                     outer_info)) {
-      if (!isolate->has_pending_exception()) isolate->StackOverflow();
-      return false;
-    }
+
+    SetSharedFunctionFlagsFromLiteral(literal, shared);

[Michael Starzinger, 2017/01/19 13:29:22]

nit: Please add a brief comment here explaining that the given {literal} has
already been numbered because AstNumbering descends into eagerly compiled
function literals.

[rmcilroy, 2017/01/19 17:24:49]

Done.

 
     // Try to enqueue the eager function on the compiler dispatcher.
     CompilerDispatcher* dispatcher = isolate->compiler_dispatcher();
     if (UseCompilerDispatcher(dispatcher, literal->scope(), shared, is_debug,
                               will_serialize) &&
         dispatcher->EnqueueAndStep(shared, literal)) {
       // If we have successfully queued up the function for compilation on the
       // compiler dispatcher then we are done.
       continue;
     } else {
@@ skipping 20 matching lines @@
   }
   return true;
 }
 
 bool CompileUnoptimizedCode(CompilationInfo* info) {
   Isolate* isolate = info->isolate();
   DCHECK(AllowCompilation::IsAllowed(isolate));
 
   Compiler::EagerInnerFunctionLiterals inner_literals;
   if (!Compiler::Analyze(info->parse_info(), &inner_literals) ||
-      !CompileUnoptimizedInnerFunctionsRecursively(&inner_literals, info) ||
+      !CompileUnoptimizedInnerFunctions(&inner_literals, info) ||
       !GenerateUnoptimizedCode(info)) {
     if (!isolate->has_pending_exception()) isolate->StackOverflow();
     return false;
   }
 
   // TODO(rmcilroy): Remove this once the enqueued tasks can keep the parsed
   // zone and handles alive and replace with a check in CompileLazy to finish
   // the task itself.
   if (isolate->compiler_dispatcher()->IsEnabled() &&
       !isolate->compiler_dispatcher()->FinishAllNow()) {
@@ skipping 1204 matching lines @@
   }
 
   if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8