Don't compile inner functions when compiling via the dispatcher

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 473 matching lines @@
   BytecodeLabels* else_labels_;
   TestFallthrough fallthrough_;
   bool result_consumed_by_test_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResultScope);
 };
 
 // Used to build a list of global declaration initial value pairs.
 class BytecodeGenerator::GlobalDeclarationsBuilder final : public ZoneObject {
  public:
-  explicit GlobalDeclarationsBuilder(Zone* zone)
+  GlobalDeclarationsBuilder(Zone* zone, LazyCompilationMode mode)
       : declarations_(0, zone),
         constant_pool_entry_(0),
-        has_constant_pool_entry_(false) {}
+        has_constant_pool_entry_(false),
+        compilation_mode_(mode) {}
 
   void AddFunctionDeclaration(Handle<String> name, FeedbackVectorSlot slot,
                               FunctionLiteral* func) {
     DCHECK(!slot.IsInvalid());
     declarations_.push_back(Declaration(name, slot, func));
   }
 
   void AddUndefinedDeclaration(Handle<String> name, FeedbackVectorSlot slot) {
     DCHECK(!slot.IsInvalid());
     declarations_.push_back(Declaration(name, slot, nullptr));
   }
 
   Handle<FixedArray> AllocateDeclarations(CompilationInfo* info) {
     DCHECK(has_constant_pool_entry_);
     int array_index = 0;
     Handle<FixedArray> data = info->isolate()->factory()->NewFixedArray(
         static_cast<int>(declarations_.size() * 3), TENURED);
     for (const Declaration& declaration : declarations_) {
       FunctionLiteral* func = declaration.func;
       Handle<Object> initial_value;
       if (func == nullptr) {
         initial_value = info->isolate()->factory()->undefined_value();
       } else {
-        initial_value =
-            Compiler::GetSharedFunctionInfo(func, info->script(), info);
+        initial_value = Compiler::GetSharedFunctionInfo(
+            func, info->script(), info, compilation_mode_);
       }
 
       // Return a null handle if any initial values can't be created. Caller
       // will set stack overflow.
       if (initial_value.is_null()) return Handle<FixedArray>();
 
       data->set(array_index++, *declaration.name);
       data->set(array_index++, Smi::FromInt(declaration.slot.ToInt()));
       data->set(array_index++, *initial_value);
     }
@@ skipping 21 matching lines @@
                 FunctionLiteral* func)
         : name(name), slot(slot), func(func) {}
 
     Handle<String> name;
     FeedbackVectorSlot slot;
     FunctionLiteral* func;
   };
   ZoneVector<Declaration> declarations_;
   size_t constant_pool_entry_;
   bool has_constant_pool_entry_;
+  LazyCompilationMode compilation_mode_;
 };
 
-BytecodeGenerator::BytecodeGenerator(CompilationInfo* info)
+BytecodeGenerator::BytecodeGenerator(CompilationInfo* info,
+                                     LazyCompilationMode mode)
     : zone_(info->zone()),
       builder_(new (zone()) BytecodeArrayBuilder(
           info->isolate(), info->zone(), info->num_parameters_including_this(),
           info->scope()->MaxNestedContextChainLength(),
           info->scope()->num_stack_slots(), info->literal(),
           info->SourcePositionRecordingMode())),
       info_(info),
       scope_(info->scope()),
-      globals_builder_(new (zone()) GlobalDeclarationsBuilder(info->zone())),
+      compilation_mode_(mode),
+      globals_builder_(new (zone())
+                           GlobalDeclarationsBuilder(info->zone(), mode)),
       global_declarations_(0, info->zone()),
       function_literals_(0, info->zone()),
       native_function_literals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
       generator_state_(),
       loop_depth_(0),
       home_object_symbol_(info->isolate()->factory()->home_object_symbol()),
@@ skipping 18 matching lines @@
     Handle<FixedArray> declarations =
         globals_builder->AllocateDeclarations(info());
     if (declarations.is_null()) return SetStackOverflow();
     builder()->InsertConstantPoolEntryAt(globals_builder->constant_pool_entry(),
                                          declarations);
   }
 
   // Find or build shared function infos.
   for (std::pair<FunctionLiteral*, size_t> literal : function_literals_) {
     FunctionLiteral* expr = literal.first;
-    Handle<SharedFunctionInfo> shared_info =
-        Compiler::GetSharedFunctionInfo(expr, info()->script(), info());
+    Handle<SharedFunctionInfo> shared_info = Compiler::GetSharedFunctionInfo(
+        expr, info()->script(), info(), compilation_mode_);
     if (shared_info.is_null()) return SetStackOverflow();
     builder()->InsertConstantPoolEntryAt(literal.second, shared_info);
   }
 
   // Find or build shared function infos for the native function templates.
   for (std::pair<NativeFunctionLiteral*, size_t> literal :
        native_function_literals_) {
     NativeFunctionLiteral* expr = literal.first;
     Handle<SharedFunctionInfo> shared_info =
         Compiler::GetSharedFunctionInfoForNative(expr->extension(),
@@ skipping 316 matching lines @@
   builder()
       ->LoadConstantPoolEntry(globals_builder()->constant_pool_entry())
       .StoreAccumulatorInRegister(args[0])
       .LoadLiteral(Smi::FromInt(encoded_flags))
       .StoreAccumulatorInRegister(args[1])
       .MoveRegister(Register::function_closure(), args[2])
       .CallRuntime(Runtime::kDeclareGlobalsForInterpreter, args);
 
   // Push and reset globals builder.
   global_declarations_.push_back(globals_builder());
-  globals_builder_ = new (zone()) GlobalDeclarationsBuilder(zone());
+  globals_builder_ =
+      new (zone()) GlobalDeclarationsBuilder(zone(), compilation_mode_);
 }
 
 void BytecodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   for (int i = 0; i < statements->length(); i++) {
     // Allocate an outer register allocations scope for the statement.
     RegisterAllocationScope allocation_scope(this);
     Statement* stmt = statements->at(i);
     Visit(stmt);
     if (stmt->IsJump()) break;
   }
@@ skipping 2322 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8