[interpreter] Remove OperandScale from front stages of pipeline.

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/base/bits.h"
 #include "src/frames.h"
 #include "src/interpreter/bytecode-traits.h"
 #include "src/interpreter/interpreter.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 
 // static
@@ skipping 566 matching lines @@
     return OperandTraits<OperandType::k##Name>::TypeInfo::kIsUnsigned;
     OPERAND_TYPE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return false;
 }
 
 // static
 OperandSize Bytecodes::SizeForSignedOperand(int value) {
-  if (kMinInt8 <= value && value <= kMaxInt8) {
-    return OperandSize::kByte;
-  } else if (kMinInt16 <= value && value <= kMaxInt16) {
-    return OperandSize::kShort;
-  } else {
-    return OperandSize::kQuad;
-  }
+  uint32_t unsigned_value = (value >= 0) ? static_cast<uint32_t>(value)
+                                         : static_cast<uint32_t>(-1 - value);
+  // Signed operands require 1-bit for the sign, hence the multiplication by 2u;
+  return SizeForUnsignedOperand(unsigned_value * 2u);

[rmcilroy, 2016/06/07 10:32:46]

I prefer the old approach we used here. Is there any reason you changed it?

[oth, 2016/06/08 15:08:41]

Done. This was just experimentation with slightly fewer branches.

 }
 
 // static
-OperandSize Bytecodes::SizeForUnsignedOperand(int value) {
-  DCHECK_GE(value, 0);
-  if (value <= kMaxUInt8) {
-    return OperandSize::kByte;
-  } else if (value <= kMaxUInt16) {
-    return OperandSize::kShort;
-  } else {
-    return OperandSize::kQuad;
-  }
-}
-
-OperandSize Bytecodes::SizeForUnsignedOperand(size_t value) {
-  if (value <= static_cast<size_t>(kMaxUInt8)) {
-    return OperandSize::kByte;
-  } else if (value <= static_cast<size_t>(kMaxUInt16)) {
-    return OperandSize::kShort;
-  } else if (value <= kMaxUInt32) {
-    return OperandSize::kQuad;
-  } else {
-    UNREACHABLE();
-    return OperandSize::kQuad;
-  }
+OperandSize Bytecodes::SizeForUnsignedOperand(uint32_t value) {
+  unsigned leading_zeros = base::bits::CountLeadingZeros32(value);
+  unsigned index = (32 - leading_zeros + 7) / 8;
+  const OperandSize kSizes[] = {OperandSize::kByte, OperandSize::kByte,
+                                OperandSize::kShort, OperandSize::kQuad,
+                                OperandSize::kQuad};
+  return kSizes[index];
 }
 
 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;
 }
 
@@ skipping 335 matching lines @@
   } else {
     std::ostringstream s;
     s << "r" << index();
     return s.str();
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8