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 228 matching lines @@
       // Walk equivalents of materialized registers, materializing
       // each equivalent register as necessary and placing in their
       // own equivalence set.
       RegisterInfo* equivalent;
       while ((equivalent = reg_info->GetEquivalent()) != reg_info) {
         if (equivalent->allocated() && !equivalent->materialized()) {
           OutputRegisterTransfer(reg_info, equivalent);
         }
         equivalent->MoveToNewEquivalenceSet(NextEquivalenceId(), true);
       }
+    } else if (reg_info->GetEquivalent() == reg_info) {
+      reg_info->MoveToNewEquivalenceSet(NextEquivalenceId(), true);

[rmcilroy, 2017/06/01 10:44:44]

Why do these need moved here? If it's because they don't count as materialized,
could we instead initialize registers as being materialized in the constructor /
GrowRegisterMap? (Flush is already expensive, so I'd rather not do more work
here if possible)

[Jarin, 2017/06/01 12:48:22]

Yes, it's because they do not count as materialized. I had added this code
because it seemed to be the safest option. 

Now it is removed and the materialization is set in GrowRegisterMap.

Thanks for the suggestion!

     }
   }
 
   flush_required_ = false;
 }
 
 void BytecodeRegisterOptimizer::OutputRegisterTransfer(
     RegisterInfo* input_info, RegisterInfo* output_info) {
   Register input = input_info->register_value();
   Register output = output_info->register_value();
@@ skipping 38 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 116 matching lines @@
 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