[interpreter] Bytecode register optimizer.

src/interpreter/bytecodes.cc

 // Copyright 2015 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/bytecodes.h"
 
 #include <iomanip>
 
 #include "src/frames.h"
 #include "src/interpreter/bytecode-traits.h"
@@ skipping 283 matching lines @@
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return nullptr;
 }
 
 // static
 OperandSize Bytecodes::GetOperandSize(Bytecode bytecode, int i,
                                       OperandScale operand_scale) {
+  DCHECK_LT(i, NumberOfOperands(bytecode));
+  return GetOperandSizes(bytecode, operand_scale)[i];
+}
+
+// static
+const OperandSize* Bytecodes::GetOperandSizes(Bytecode bytecode,
+                                              OperandScale operand_scale) {
   DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
-    return BytecodeTraits<__VA_ARGS__>::GetOperandSize(i, operand_scale);
+    return BytecodeTraits<__VA_ARGS__>::GetOperandSizes(operand_scale);
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
-  return OperandSize::kNone;
+  return nullptr;
 }
 
 // static
 int Bytecodes::GetRegisterOperandBitmap(Bytecode bytecode) {
   DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)                              \
   case Bytecode::k##Name:                            \
     typedef BytecodeTraits<__VA_ARGS__> Name##Trait; \
     return Name##Trait::kRegisterOperandBitmap;
@@ skipping 288 matching lines @@
   } else if (value <= static_cast<size_t>(kMaxUInt16)) {
     return OperandSize::kShort;
   } else if (value <= kMaxUInt32) {
     return OperandSize::kQuad;
   } else {
     UNREACHABLE();
     return OperandSize::kQuad;
   }
 }
 
+OperandScale Bytecodes::OperandSizesToScale(OperandSize size0) {
+  OperandScale operand_scale = static_cast<OperandScale>(size0);
+  DCHECK(operand_scale == OperandScale::kSingle ||
+         operand_scale == OperandScale::kDouble ||
+         operand_scale == OperandScale::kQuadruple);
+  return operand_scale;
+}
+
+OperandScale Bytecodes::OperandSizesToScale(OperandSize size0,
+                                            OperandSize size1) {
+  OperandSize operand_size = std::max(size0, size1);
+  // Operand sizes have been scaled before calling this function.
+  // Currently all scalable operands are byte sized at
+  // OperandScale::kSingle.
+  STATIC_ASSERT(static_cast<int>(OperandSize::kByte) ==
+                    static_cast<int>(OperandScale::kSingle) &&
+                static_cast<int>(OperandSize::kShort) ==
+                    static_cast<int>(OperandScale::kDouble) &&
+                static_cast<int>(OperandSize::kQuad) ==
+                    static_cast<int>(OperandScale::kQuadruple));
+  OperandScale operand_scale = static_cast<OperandScale>(operand_size);
+  DCHECK(operand_scale == OperandScale::kSingle ||
+         operand_scale == OperandScale::kDouble ||
+         operand_scale == OperandScale::kQuadruple);
+  return operand_scale;
+}
+
 OperandScale Bytecodes::OperandSizesToScale(OperandSize size0,
                                             OperandSize size1,
                                             OperandSize size2,
                                             OperandSize size3) {
   OperandSize upper = std::max(size0, size1);
   OperandSize lower = std::max(size2, size3);
   OperandSize result = std::max(upper, lower);
   // Operand sizes have been scaled before calling this function.
   // Currently all scalable operands are byte sized at
   // OperandScale::kSingle.
@@ skipping 191 matching lines @@
      InterpreterFrameConstants::kNewTargetFromFp) /
     kPointerSize;
 static const int kBytecodeArrayRegisterIndex =
     (InterpreterFrameConstants::kRegisterFileFromFp -
      InterpreterFrameConstants::kBytecodeArrayFromFp) /
     kPointerSize;
 static const int kBytecodeOffsetRegisterIndex =
     (InterpreterFrameConstants::kRegisterFileFromFp -
      InterpreterFrameConstants::kBytecodeOffsetFromFp) /
     kPointerSize;
+static const int kCallerPCOffsetRegisterIndex =
+    (InterpreterFrameConstants::kRegisterFileFromFp -
+     InterpreterFrameConstants::kCallerPCOffsetFromFp) /
+    kPointerSize;
 
 Register Register::FromParameterIndex(int index, int parameter_count) {
   DCHECK_GE(index, 0);
   DCHECK_LT(index, parameter_count);
   int register_index = kLastParamRegisterIndex - parameter_count + index + 1;
   DCHECK_LT(register_index, 0);
   return Register(register_index);
 }
 
 int Register::ToParameterIndex(int parameter_count) const {
@@ skipping 32 matching lines @@
 }
 
 Register Register::bytecode_offset() {
   return Register(kBytecodeOffsetRegisterIndex);
 }
 
 bool Register::is_bytecode_offset() const {
   return index() == kBytecodeOffsetRegisterIndex;
 }
 
+// static
+Register Register::virtual_accumulator() {
+  return Register(kCallerPCOffsetRegisterIndex);
+}
+
 OperandSize Register::SizeOfOperand() const {
   int32_t operand = ToOperand();
   if (operand >= kMinInt8 && operand <= kMaxInt8) {
     return OperandSize::kByte;
   } else if (operand >= kMinInt16 && operand <= kMaxInt16) {
     return OperandSize::kShort;
   } else {
     return OperandSize::kQuad;
   }
 }
@@ skipping 34 matching lines @@
   } else {
     std::ostringstream s;
     s << "r" << index();
     return s.str();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8