[interpreter] Streamline bytecode array writing.

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 486 matching lines @@
 void BytecodeRegisterOptimizer::PrepareRegisterOperands(
     BytecodeNode* const node) {
   //
   // For each input operand, get a materialized equivalent if it is
   // just a single register, otherwise materialize register range.
   // Update operand_scale if necessary.
   //
   // For each output register about to be clobbered, materialize an
   // equivalent if it exists. Put each register in it's own equivalence set.
   //
-  int register_operand_bitmap =
-      Bytecodes::GetRegisterOperandBitmap(node->bytecode());
+  const uint32_t* operands = node->operands();
+  int operand_count = node->operand_count();
   const OperandType* operand_types =
       Bytecodes::GetOperandTypes(node->bytecode());
-  uint32_t* operands = node->operands();
-  for (int i = 0; register_operand_bitmap != 0;
-       ++i, register_operand_bitmap >>= 1) {
-    if ((register_operand_bitmap & 1) == 0) {
-      continue;
-    }
-    OperandType operand_type = operand_types[i];
-    int count = 0;
+  for (int i = 0; i < operand_count; ++i) {
+    int count;
+    // operand_types is terminated by OperandType::kNone so this does not
+    // go out of bounds.
     if (operand_types[i + 1] == OperandType::kRegCount) {
       count = static_cast<int>(operands[i + 1]);
-      if (count == 0) {
-        continue;
-      }
     } else {
-      count = Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type);
+      count = Bytecodes::GetNumberOfRegistersRepresentedBy(operand_types[i]);
+    }
+
+    if (count == 0) {
+      continue;
     }
 
     Register reg = Register::FromOperand(static_cast<int32_t>(operands[i]));
-    if (Bytecodes::IsRegisterInputOperandType(operand_type)) {
+    if (Bytecodes::IsRegisterInputOperandType(operand_types[i])) {
       if (count == 1) {
         PrepareRegisterInputOperand(node, reg, i);
       } else if (count > 1) {
         PrepareRegisterRangeInputOperand(reg, count);
       }
-    } else if (Bytecodes::IsRegisterOutputOperandType(operand_type)) {
+    } else if (Bytecodes::IsRegisterOutputOperandType(operand_types[i])) {
       PrepareRegisterRangeOutputOperand(reg, count);
     }
   }
 }
 
 void BytecodeRegisterOptimizer::PrepareAccumulator(BytecodeNode* const node) {
   // 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(node->bytecode()) &&
@@ skipping 75 matching lines @@
     if (info->materialized()) {
       CreateMaterializedEquivalent(info);
     }
     info->MoveToNewEquivalenceSet(kInvalidEquivalenceId, false);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8