[Interpreter] Consistency fixes.

src/interpreter/bytecode-array-builder.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/bytecode-array-builder.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(Isolate* isolate)
     : isolate_(isolate),
       bytecode_generated_(false),
       local_register_count_(-1),
       temporary_register_count_(0),
       temporary_register_next_(0) {}
 
 
 void BytecodeArrayBuilder::set_locals_count(int number_of_locals) {
   local_register_count_ = number_of_locals;
   temporary_register_next_ = local_register_count_;
 }
 
 
 int BytecodeArrayBuilder::locals_count() const { return local_register_count_; }
 
+
 Handle<BytecodeArray> BytecodeArrayBuilder::ToBytecodeArray() {
   DCHECK_EQ(bytecode_generated_, false);
   DCHECK_GE(local_register_count_, 0);
   int bytecode_size = static_cast<int>(bytecodes_.size());
   int register_count = local_register_count_ + temporary_register_count_;
   int frame_size = register_count * kPointerSize;
   Handle<BytecodeArray> output = isolate_->factory()->NewBytecodeArray(
       bytecode_size, &bytecodes_.front(), frame_size);
   bytecode_generated_ = true;
   return output;
@@ skipping 113 matching lines @@
          OperandIsValid(bytecode, 2, operand2));
   bytecodes_.push_back(Bytecodes::ToByte(bytecode));
   bytecodes_.push_back(operand0);
   bytecodes_.push_back(operand1);
   bytecodes_.push_back(operand2);
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint8_t operand0,
                                   uint8_t operand1) {
-  DCHECK(Bytecodes::NumberOfOperands(bytecode) == 2);
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 2);
   DCHECK(OperandIsValid(bytecode, 0, operand0) &&
          OperandIsValid(bytecode, 1, operand1));
   bytecodes_.push_back(Bytecodes::ToByte(bytecode));
   bytecodes_.push_back(operand0);
   bytecodes_.push_back(operand1);
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode, uint8_t operand0) {
-  DCHECK(Bytecodes::NumberOfOperands(bytecode) == 1);
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 1);
   DCHECK(OperandIsValid(bytecode, 0, operand0));
   bytecodes_.push_back(Bytecodes::ToByte(bytecode));
   bytecodes_.push_back(operand0);
 }
 
 
 void BytecodeArrayBuilder::Output(Bytecode bytecode) {
-  DCHECK(Bytecodes::NumberOfOperands(bytecode) == 0);
+  DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 0);
   bytecodes_.push_back(Bytecodes::ToByte(bytecode));
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForBinaryOperation(Token::Value op) {
   switch (op) {
     case Token::Value::ADD:
       return Bytecode::kAdd;
     case Token::Value::SUB:
@@ skipping 22 matching lines @@
 
 int TemporaryRegisterScope::NewRegister() {
   count_++;
   register_ = builder_->BorrowTemporaryRegister();
   return register_;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8