[Interpreter] Remove extra CHECKS added for crbug.com/642111.

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/globals.h"
@@ skipping 135 matching lines @@
   return size;
 }
 
 // static
 size_t Bytecodes::ReturnCount(Bytecode bytecode) {
   return bytecode == Bytecode::kReturn ? 1 : 0;
 }
 
 // static
 int Bytecodes::NumberOfOperands(Bytecode bytecode) {
-  CHECK(bytecode <= Bytecode::kLast);
+  DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return BytecodeTraits<__VA_ARGS__>::kOperandCount;
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return 0;
 }
@@ skipping 136 matching lines @@
 bool Bytecodes::IsWithoutExternalSideEffects(Bytecode bytecode) {
   // These bytecodes only manipulate interpreter frame state and will
   // never throw.
   return (IsAccumulatorLoadWithoutEffects(bytecode) ||
           IsRegisterLoadWithoutEffects(bytecode) ||
           bytecode == Bytecode::kNop || IsJumpWithoutEffects(bytecode));
 }
 
 // static
 OperandType Bytecodes::GetOperandType(Bytecode bytecode, int i) {
-  CHECK_LE(bytecode, Bytecode::kLast);
-  CHECK_LT(i, NumberOfOperands(bytecode));
-  CHECK_GE(i, 0);
+  DCHECK_LE(bytecode, Bytecode::kLast);
+  DCHECK_LT(i, NumberOfOperands(bytecode));
+  DCHECK_GE(i, 0);
   return GetOperandTypes(bytecode)[i];
 }
 
 // static
 const OperandType* Bytecodes::GetOperandTypes(Bytecode bytecode) {
-  CHECK_LE(bytecode, Bytecode::kLast);
+  DCHECK_LE(bytecode, Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return BytecodeTraits<__VA_ARGS__>::GetOperandTypes();
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return nullptr;
 }
 
 // static
 const OperandTypeInfo* Bytecodes::GetOperandTypeInfos(Bytecode bytecode) {
   DCHECK(bytecode <= Bytecode::kLast);
   switch (bytecode) {
 #define CASE(Name, ...)   \
   case Bytecode::k##Name: \
     return BytecodeTraits<__VA_ARGS__>::GetOperandTypeInfos();
     BYTECODE_LIST(CASE)
 #undef CASE
   }
   UNREACHABLE();
   return nullptr;
 }
 
 // static
 OperandSize Bytecodes::GetOperandSize(Bytecode bytecode, int i,
                                       OperandScale operand_scale) {
-  CHECK_LT(i, NumberOfOperands(bytecode));
+  DCHECK_LT(i, NumberOfOperands(bytecode));
   OperandType operand_type = GetOperandType(bytecode, i);
   return SizeOfOperand(operand_type, operand_scale);
 }
 
 // static
 int Bytecodes::GetOperandOffset(Bytecode bytecode, int i,
                                 OperandScale operand_scale) {
   DCHECK_LT(i, Bytecodes::NumberOfOperands(bytecode));
   // TODO(oth): restore this to a statically determined constant.
   int offset = 1;
   for (int operand_index = 0; operand_index < i; ++operand_index) {
     OperandSize operand_size =
         GetOperandSize(bytecode, operand_index, operand_scale);
     offset += static_cast<int>(operand_size);
   }
   return offset;
 }
 
 // static
 OperandSize Bytecodes::SizeOfOperand(OperandType operand_type,
                                      OperandScale operand_scale) {
-  CHECK_LE(operand_type, OperandType::kLast);
-  CHECK_GE(operand_scale, OperandScale::kSingle);
-  CHECK_LE(operand_scale, OperandScale::kLast);
+  DCHECK_LE(operand_type, OperandType::kLast);
+  DCHECK_GE(operand_scale, OperandScale::kSingle);
+  DCHECK_LE(operand_scale, OperandScale::kLast);
   return static_cast<OperandSize>(
       ScaledOperandSize(operand_type, operand_scale));
 }
 
 // static
 bool Bytecodes::IsConditionalJumpImmediate(Bytecode bytecode) {
   return bytecode == Bytecode::kJumpIfTrue ||
          bytecode == Bytecode::kJumpIfFalse ||
          bytecode == Bytecode::kJumpIfToBooleanTrue ||
          bytecode == Bytecode::kJumpIfToBooleanFalse ||
@@ skipping 293 matching lines @@
   return os << Bytecodes::OperandScaleToString(operand_scale);
 }
 
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type) {
   return os << Bytecodes::OperandTypeToString(operand_type);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8