[Interpreter] Templatize AccumulatorUsage and OperandType for bytecode creation.

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 247 matching lines @@
 
 void BytecodeRegisterOptimizer::OutputRegisterTransfer(
     RegisterInfo* input_info, RegisterInfo* output_info,
     BytecodeSourceInfo source_info) {
   Register input = input_info->register_value();
   Register output = output_info->register_value();
   DCHECK_NE(input.index(), output.index());
 
   if (input == accumulator_) {
     uint32_t operand = static_cast<uint32_t>(output.ToOperand());
-    BytecodeNode node(Bytecode::kStar, operand, source_info);
+    BytecodeNode node =
+        BytecodeNode::Create<Bytecode::kStar, OperandType::kRegOut>(

[Leszek Swirski, 2016/12/05 10:57:42]

This seems error prone -- would it be worth having bytecode-templated create
functions with no other template parameters, that then are specialized (with the
help of BYTECODE_LIST) to have the correct operands?

[rmcilroy, 2016/12/09 09:21:05]

Good idea, done (as differently named functions rather than bytecode-templated
specialized functions) .  I've also added DCHECKS in the Create functions to
make sure the bytecode operand types match the template. 

+            operand, source_info);
     next_stage_->Write(&node);
   } else if (output == accumulator_) {
     uint32_t operand = static_cast<uint32_t>(input.ToOperand());
-    BytecodeNode node(Bytecode::kLdar, operand, source_info);
+    BytecodeNode node =
+        BytecodeNode::Create<Bytecode::kLdar, OperandType::kReg>(operand,
+                                                                 source_info);
     next_stage_->Write(&node);
   } else {
     uint32_t operand0 = static_cast<uint32_t>(input.ToOperand());
     uint32_t operand1 = static_cast<uint32_t>(output.ToOperand());
-    BytecodeNode node(Bytecode::kMov, operand0, operand1, source_info);
+    BytecodeNode node = BytecodeNode::Create<Bytecode::kMov, OperandType::kReg,
+                                             OperandType::kRegOut>(
+        operand0, operand1, source_info);
     next_stage_->Write(&node);
   }
   if (output != accumulator_) {
     max_register_index_ = std::max(max_register_index_, output.index());
   }
   output_info->set_materialized(true);
 }
 
 void BytecodeRegisterOptimizer::CreateMaterializedEquivalent(
     RegisterInfo* info) {
@@ skipping 70 matching lines @@
   if (input_is_observable) {
     // If input is observable by the debugger, mark all other temporaries
     // registers as unmaterialized so that this register is used in preference.
     input_info->MarkTemporariesAsUnmaterialized(temporary_base_);
   }
 }
 
 void BytecodeRegisterOptimizer::EmitNopForSourceInfo(
     BytecodeSourceInfo source_info) const {
   DCHECK(source_info.is_valid());
-  BytecodeNode nop(Bytecode::kNop, source_info);
+  BytecodeNode nop = BytecodeNode::Create<Bytecode::kNop>(source_info);
   next_stage_->Write(&nop);
 }
 
 void BytecodeRegisterOptimizer::PrepareOutputRegister(Register reg) {
   RegisterInfo* reg_info = GetRegisterInfo(reg);
   if (reg_info->materialized()) {
     CreateMaterializedEquivalent(reg_info);
   }
   reg_info->MoveToNewEquivalenceSet(NextEquivalenceId(), true);
   max_register_index_ =
@@ skipping 30 matching lines @@
     int start_index = reg_list.first_register().index();
     for (int i = 0; i < reg_list.register_count(); ++i) {
       Register current(start_index + i);
       RegisterInfo* input_info = GetRegisterInfo(current);
       Materialize(input_info);
     }
     return reg_list;
   }
 }
 
-void BytecodeRegisterOptimizer::PrepareForBytecode(Bytecode bytecode) {
-  if (Bytecodes::IsJump(bytecode) || bytecode == Bytecode::kDebugger ||
-      bytecode == Bytecode::kSuspendGenerator) {
-    // All state must be flushed before emitting
-    // - a jump bytecode (as the register equivalents at the jump target aren't
-    //   known.
-    // - a call to the debugger (as it can manipulate locals and parameters),
-    // - a generator suspend (as this involves saving all registers).
-    Flush();
-  }
-
-  // Materialize the accumulator if it is read by the bytecode. The
-  // accumulator is special and no other register can be materialized
-  // in it's place.
-  if (Bytecodes::ReadsAccumulator(bytecode) &&
-      !accumulator_info_->materialized()) {
-    Materialize(accumulator_info_);
-  }
-
-  // Materialize an equivalent to the accumulator if it will be
-  // clobbered when the bytecode is dispatched.
-  if (Bytecodes::WritesAccumulator(bytecode)) {
-    PrepareOutputRegister(accumulator_);
-  }
-}
-
 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),
@@ skipping 20 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