Don't compile inner functions when compiling via the dispatcher

src/full-codegen/full-codegen.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/full-codegen/full-codegen.h"
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/ast.h"
 #include "src/ast/prettyprinter.h"
 #include "src/ast/scopes.h"
@@ skipping 10 matching lines @@
 #include "src/snapshot/snapshot.h"
 #include "src/tracing/trace-event.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm())
 
 class FullCodegenCompilationJob final : public CompilationJob {
  public:
-  explicit FullCodegenCompilationJob(CompilationInfo* info)
-      : CompilationJob(info->isolate(), info, "Full-Codegen") {}
+  FullCodegenCompilationJob(CompilationInfo* info, LazyCompilationMode mode)
+      : CompilationJob(info->isolate(), info, "Full-Codegen"), mode_(mode) {}
 
   bool can_execute_on_background_thread() const override { return false; }
 
   CompilationJob::Status PrepareJobImpl() final { return SUCCEEDED; }
 
   CompilationJob::Status ExecuteJobImpl() final {
     DCHECK(ThreadId::Current().Equals(isolate()->thread_id()));
-    return FullCodeGenerator::MakeCode(info(), stack_limit()) ? SUCCEEDED
-                                                              : FAILED;
+    return FullCodeGenerator::MakeCode(info(), stack_limit(), mode_) ? SUCCEEDED
+                                                                     : FAILED;
   }
 
   CompilationJob::Status FinalizeJobImpl() final { return SUCCEEDED; }
+
+ private:
+  LazyCompilationMode mode_;
+
+  DISALLOW_COPY_AND_ASSIGN(FullCodegenCompilationJob);
 };
 
 FullCodeGenerator::FullCodeGenerator(MacroAssembler* masm,
                                      CompilationInfo* info,
-                                     uintptr_t stack_limit)
+                                     uintptr_t stack_limit,
+                                     LazyCompilationMode mode)
     : masm_(masm),
       info_(info),
       isolate_(info->isolate()),
+      compilation_mode_(mode),
       zone_(info->zone()),
       scope_(info->scope()),
       nesting_stack_(NULL),
       loop_depth_(0),
       operand_stack_depth_(0),
       globals_(NULL),
       context_(NULL),
       bailout_entries_(info->HasDeoptimizationSupport()
                            ? info->literal()->ast_node_count()
                            : 0,
                        info->zone()),
       back_edges_(2, info->zone()),
       source_position_table_builder_(info->zone(),
                                      info->SourcePositionRecordingMode()),
       ic_total_count_(0) {
   DCHECK(!info->IsStub());
   Initialize(stack_limit);
 }
 
 // static
-CompilationJob* FullCodeGenerator::NewCompilationJob(CompilationInfo* info) {
-  return new FullCodegenCompilationJob(info);
+CompilationJob* FullCodeGenerator::NewCompilationJob(CompilationInfo* info,
+                                                     LazyCompilationMode mode) {
+  return new FullCodegenCompilationJob(info, mode);
 }
 
 // static
 bool FullCodeGenerator::MakeCode(CompilationInfo* info) {
-  return MakeCode(info, info->isolate()->stack_guard()->real_climit());
+  return MakeCode(info, info->isolate()->stack_guard()->real_climit(),
+                  LazyCompilationMode::kIfRequested);
 }
 
 // static
-bool FullCodeGenerator::MakeCode(CompilationInfo* info, uintptr_t stack_limit) {
+bool FullCodeGenerator::MakeCode(CompilationInfo* info, uintptr_t stack_limit,
+                                 LazyCompilationMode mode) {
   Isolate* isolate = info->isolate();
 
   DCHECK(!info->shared_info()->must_use_ignition_turbo());
   DCHECK(!FLAG_minimal);
   RuntimeCallTimerScope runtimeTimer(isolate,
                                      &RuntimeCallStats::CompileFullCode);
   TimerEventScope<TimerEventCompileFullCode> timer(info->isolate());
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.CompileFullCode");
 
   Handle<Script> script = info->script();
   if (!script->IsUndefined(isolate) &&
       !script->source()->IsUndefined(isolate)) {
     int len = String::cast(script->source())->length();
     isolate->counters()->total_full_codegen_source_size()->Increment(len);
   }
   CodeGenerator::MakeCodePrologue(info, "full");
   const int kInitialBufferSize = 4 * KB;
   MacroAssembler masm(info->isolate(), NULL, kInitialBufferSize,
                       CodeObjectRequired::kYes);
   if (info->will_serialize()) masm.enable_serializer();
 
-  FullCodeGenerator cgen(&masm, info, stack_limit);
+  FullCodeGenerator cgen(&masm, info, stack_limit, mode);
   cgen.Generate();
   if (cgen.HasStackOverflow()) {
     DCHECK(!isolate->has_pending_exception());
     return false;
   }
   unsigned table_offset = cgen.EmitBackEdgeTable();
 
   Handle<Code> code =
       CodeGenerator::MakeCodeEpilogue(&masm, nullptr, info, masm.CodeObject());
   cgen.PopulateDeoptimizationData(code);
@@ skipping 1162 matching lines @@
   Comment cmnt(masm_, "[ Literal");
   context()->Plug(expr->value());
 }
 
 
 void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
   // Build the function boilerplate and instantiate it.
   Handle<SharedFunctionInfo> function_info =
-      Compiler::GetSharedFunctionInfo(expr, script(), info_);
+      Compiler::GetSharedFunctionInfo(expr, script(), info_, compilation_mode_);
   if (function_info.is_null()) {
     SetStackOverflow();
     return;
   }
   EmitNewClosure(function_info, expr->pretenure());
 }
 
 
 void FullCodeGenerator::VisitClassLiteral(ClassLiteral* lit) {
   // Unsupported
@@ skipping 303 matching lines @@
   return info_->has_simple_parameters();
 }
 
 FunctionLiteral* FullCodeGenerator::literal() const { return info_->literal(); }
 
 #undef __
 
 
 }  // namespace internal
 }  // namespace v8