[interpreter] Bytecode register optimizer.

test/unittests/interpreter/bytecodes-unittest.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 <vector>
 
 #include "src/v8.h"
 
 #include "src/interpreter/bytecodes.h"
 #include "test/unittests/interpreter/bytecode-utils.h"
@@ skipping 314 matching lines @@
   CHECK(!Bytecodes::OperandScaleRequiresPrefixBytecode(OperandScale::kSingle));
   CHECK(Bytecodes::OperandScaleRequiresPrefixBytecode(OperandScale::kDouble));
   CHECK(
       Bytecodes::OperandScaleRequiresPrefixBytecode(OperandScale::kQuadruple));
   CHECK(Bytecodes::OperandScaleToPrefixBytecode(OperandScale::kDouble) ==
         Bytecode::kWide);
   CHECK(Bytecodes::OperandScaleToPrefixBytecode(OperandScale::kQuadruple) ==
         Bytecode::kExtraWide);
 }
 
+TEST(Bytecodes, OperandSizesToScale) {
+  CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kByte),
+           OperandScale::kSingle);
+  CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kShort),
+           OperandScale::kDouble);
+  CHECK_EQ(Bytecodes::OperandSizesToScale(OperandSize::kQuad),
+           OperandScale::kQuadruple);
+  CHECK_EQ(
+      Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
+                                     OperandSize::kShort, OperandSize::kShort),
+      OperandScale::kDouble);
+  CHECK_EQ(
+      Bytecodes::OperandSizesToScale(OperandSize::kQuad, OperandSize::kShort,
+                                     OperandSize::kShort, OperandSize::kShort),
+      OperandScale::kQuadruple);
+  CHECK_EQ(
+      Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kQuad,
+                                     OperandSize::kShort, OperandSize::kShort),
+      OperandScale::kQuadruple);
+  CHECK_EQ(
+      Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
+                                     OperandSize::kQuad, OperandSize::kShort),
+      OperandScale::kQuadruple);
+  CHECK_EQ(
+      Bytecodes::OperandSizesToScale(OperandSize::kShort, OperandSize::kShort,
+                                     OperandSize::kShort, OperandSize::kQuad),
+      OperandScale::kQuadruple);
+}
+
 TEST(AccumulatorUse, LogicalOperators) {
   CHECK_EQ(AccumulatorUse::kNone | AccumulatorUse::kRead,
            AccumulatorUse::kRead);
   CHECK_EQ(AccumulatorUse::kRead | AccumulatorUse::kWrite,
            AccumulatorUse::kReadWrite);
   CHECK_EQ(AccumulatorUse::kRead & AccumulatorUse::kReadWrite,
            AccumulatorUse::kRead);
   CHECK_EQ(AccumulatorUse::kRead & AccumulatorUse::kWrite,
            AccumulatorUse::kNone);
 }
@@ skipping 14 matching lines @@
 }
 
 TEST(AccumulatorUse, AccumulatorUseToString) {
   std::set<std::string> names;
   names.insert(Bytecodes::AccumulatorUseToString(AccumulatorUse::kNone));
   names.insert(Bytecodes::AccumulatorUseToString(AccumulatorUse::kRead));
   names.insert(Bytecodes::AccumulatorUseToString(AccumulatorUse::kWrite));
   names.insert(Bytecodes::AccumulatorUseToString(AccumulatorUse::kReadWrite));
   CHECK_EQ(names.size(), 4);
 }
-
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8