Save/restore only live registers in the generator suspend/resume.

src/interpreter/bytecode-array-builder.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-array-builder.h"
 
 #include "src/globals.h"
 #include "src/interpreter/bytecode-array-writer.h"
 #include "src/interpreter/bytecode-jump-table.h"
 #include "src/interpreter/bytecode-label.h"
@@ skipping 244 matching lines @@
 
 template <>
 class OperandHelper<OperandType::kRegOut> {
  public:
   INLINE(static uint32_t Convert(BytecodeArrayBuilder* builder, Register reg)) {
     return builder->GetOutputRegisterOperand(reg);
   }
 };
 
 template <>
+class OperandHelper<OperandType::kRegOutList> {
+ public:
+  INLINE(static uint32_t Convert(BytecodeArrayBuilder* builder,
+                                 RegisterList reg_list)) {
+    return builder->GetOutputRegisterListOperand(reg_list);
+  }
+};
+
+template <>
 class OperandHelper<OperandType::kRegOutPair> {
  public:
   INLINE(static uint32_t Convert(BytecodeArrayBuilder* builder,
                                  RegisterList reg_list)) {
     DCHECK_EQ(2, reg_list.register_count());
     return builder->GetOutputRegisterListOperand(reg_list);
   }
 };
 
 template <>
@@ skipping 953 matching lines @@
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::LoadModuleVariable(int cell_index,
                                                                int depth) {
   OutputLdaModuleVariable(cell_index, depth);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::SuspendGenerator(
-    Register generator, SuspendFlags flags) {
-  OutputSuspendGenerator(generator,
+    Register generator, RegisterList registers, SuspendFlags flags) {
+  OutputSuspendGenerator(generator, registers, registers.register_count(),
                          SuspendGeneratorBytecodeFlags::Encode(flags));
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::ResumeGenerator(
+BytecodeArrayBuilder& BytecodeArrayBuilder::RestoreGeneratorState(
     Register generator) {
-  OutputResumeGenerator(generator);
+  OutputRestoreGeneratorState(generator);
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::RestoreGeneratorRegisters(
+    Register generator, RegisterList registers) {
+  OutputRestoreGeneratorRegisters(generator, registers,
+                                  registers.register_count());
+  return *this;
+}
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkHandler(
     int handler_id, HandlerTable::CatchPrediction catch_prediction) {
   BytecodeLabel handler;
   Bind(&handler);
   handler_table_builder()->SetHandlerTarget(handler_id, handler.offset());
   handler_table_builder()->SetPrediction(handler_id, catch_prediction);
   return *this;
 }
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::MarkTryBegin(int handler_id,
@@ skipping 253 matching lines @@
       return os << "AlreadyBoolean";
     case BytecodeArrayBuilder::ToBooleanMode::kConvertToBoolean:
       return os << "ConvertToBoolean";
   }
   UNREACHABLE();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8