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

src/interpreter/bytecode-register-optimizer.cc

 // Copyright 2016 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-register-optimizer.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 286 matching lines @@
     Materialize(info);
     result = info;
   }
   DCHECK(result->register_value() != accumulator_);
   return result;
 }
 
 void BytecodeRegisterOptimizer::Materialize(RegisterInfo* info) {
   if (!info->materialized()) {
     RegisterInfo* materialized = info->GetMaterializedEquivalent();
+    DCHECK_NOT_NULL(materialized);
     OutputRegisterTransfer(materialized, info);
   }
 }
 
 void BytecodeRegisterOptimizer::AddToEquivalenceSet(
     RegisterInfo* set_member, RegisterInfo* non_set_member) {
   non_set_member->AddToEquivalenceSetOf(set_member);
   // Flushing is only required when two or more registers are placed
   // in the same equivalence set.
   flush_required_ = true;
@@ skipping 86 matching lines @@
 void BytecodeRegisterOptimizer::GrowRegisterMap(Register reg) {
   DCHECK(RegisterIsTemporary(reg));
   size_t index = GetRegisterInfoTableIndex(reg);
   if (index >= register_info_table_.size()) {
     size_t new_size = index + 1;
     size_t old_size = register_info_table_.size();
     register_info_table_.resize(new_size);
     for (size_t i = old_size; i < new_size; ++i) {
       register_info_table_[i] =
           new (zone()) RegisterInfo(RegisterFromRegisterInfoTableIndex(i),
-                                    NextEquivalenceId(), false, false);
+                                    NextEquivalenceId(), true, false);
     }
   }
 }
 
 void BytecodeRegisterOptimizer::RegisterAllocateEvent(Register reg) {
   GetOrCreateRegisterInfo(reg)->set_allocated(true);
 }
 
 void BytecodeRegisterOptimizer::RegisterListAllocateEvent(
     RegisterList reg_list) {
   if (reg_list.register_count() != 0) {
     int first_index = reg_list.first_register().index();
     GrowRegisterMap(Register(first_index + reg_list.register_count() - 1));
     for (int i = 0; i < reg_list.register_count(); i++) {
       GetRegisterInfo(Register(first_index + i))->set_allocated(true);
     }
   }
 }
 
 void BytecodeRegisterOptimizer::RegisterListFreeEvent(RegisterList reg_list) {
   int first_index = reg_list.first_register().index();
   for (int i = 0; i < reg_list.register_count(); i++) {
     GetRegisterInfo(Register(first_index + i))->set_allocated(false);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8