[interpreter] Remove OperandScale from front stages of pipeline.

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 306 matching lines @@
 
 void BytecodeRegisterOptimizer::OutputRegisterTransfer(
     RegisterInfo* input_info, RegisterInfo* output_info,
     const 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());
-    OperandScale scale = Bytecodes::OperandSizesToScale(output.SizeOfOperand());
-    BytecodeNode node(Bytecode::kStar, operand, scale);
+    BytecodeNode node(Bytecode::kStar, operand);
     WriteToNextStage(&node, source_info);
   } else if (output == accumulator_) {
     uint32_t operand = static_cast<uint32_t>(input.ToOperand());
-    OperandScale scale = Bytecodes::OperandSizesToScale(input.SizeOfOperand());
-    BytecodeNode node(Bytecode::kLdar, operand, scale);
+    BytecodeNode node(Bytecode::kLdar, operand);
     WriteToNextStage(&node, source_info);
   } else {
     uint32_t operand0 = static_cast<uint32_t>(input.ToOperand());
     uint32_t operand1 = static_cast<uint32_t>(output.ToOperand());
-    OperandScale scale = Bytecodes::OperandSizesToScale(input.SizeOfOperand(),
-                                                        output.SizeOfOperand());
-    BytecodeNode node(Bytecode::kMov, operand0, operand1, scale);
+    BytecodeNode node(Bytecode::kMov, operand0, operand1);
     WriteToNextStage(&node, source_info);
   }
   output_info->set_materialized(true);
 }
 
 void BytecodeRegisterOptimizer::CreateMaterializedEquivalent(
     RegisterInfo* info) {
   DCHECK(info->materialized());
   RegisterInfo* unmaterialized = info->GetEquivalentToMaterialize();
   if (unmaterialized) {
@@ skipping 125 matching lines @@
         GetMaterializedEquivalentNotAccumulator(reg_info);
     return equivalent_info->register_value();
   }
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterInputOperand(
     BytecodeNode* const node, Register reg, int operand_index) {
   Register equivalent = GetEquivalentRegisterForInputOperand(reg);
   node->operands()[operand_index] =
       static_cast<uint32_t>(equivalent.ToOperand());
-  // Update operand scale as equivalent may be different.
-  OperandScale operand_scale =
-      Bytecodes::OperandSizesToScale(equivalent.SizeOfOperand());
-  if (operand_scale > node->operand_scale()) {
-    node->set_operand_scale(operand_scale);
-  }
 }
 
 void BytecodeRegisterOptimizer::PrepareRegisterRangeInputOperand(Register start,
                                                                  int count) {
   for (int i = 0; i < count; ++i) {
     Register current(start.index() + i);
     RegisterInfo* input_info = GetRegisterInfo(current);
     Materialize(input_info);
   }
 }
@@ skipping 125 matching lines @@
     if (info->materialized()) {
       CreateMaterializedEquivalent(info);
     }
     info->MoveToNewEquivalenceSet(kInvalidEquivalenceId, false);
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8