[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 291 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 279 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 297 matching lines @@
   } else {
     std::ostringstream s;
     s << "r" << index();
     return s.str();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8