Add support for enabling DCHECKs in release mode

src/hydrogen-instructions.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/base/bits.h"
 #include "src/double.h"
 #include "src/factory.h"
 #include "src/hydrogen-infer-representation.h"
@@ skipping 182 matching lines @@
   return 0xffffffff;
 }
 
 
 void Range::AddConstant(int32_t value) {
   if (value == 0) return;
   bool may_overflow = false;  // Overflow is ignored here.
   Representation r = Representation::Integer32();
   lower_ = AddWithoutOverflow(r, lower_, value, &may_overflow);
   upper_ = AddWithoutOverflow(r, upper_, value, &may_overflow);
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Verify();
 #endif
 }
 
 
 void Range::Intersect(Range* other) {
   upper_ = Min(upper_, other->upper_);
   lower_ = Max(lower_, other->lower_);
   bool b = CanBeMinusZero() && other->CanBeMinusZero();
   set_can_be_minus_zero(b);
@@ skipping 42 matching lines @@
   }
   set_can_be_minus_zero(false);
 }
 
 
 bool Range::AddAndCheckOverflow(const Representation& r, Range* other) {
   bool may_overflow = false;
   lower_ = AddWithoutOverflow(r, lower_, other->lower(), &may_overflow);
   upper_ = AddWithoutOverflow(r, upper_, other->upper(), &may_overflow);
   KeepOrder();
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Verify();
 #endif
   return may_overflow;
 }
 
 
 bool Range::SubAndCheckOverflow(const Representation& r, Range* other) {
   bool may_overflow = false;
   lower_ = SubWithoutOverflow(r, lower_, other->upper(), &may_overflow);
   upper_ = SubWithoutOverflow(r, upper_, other->lower(), &may_overflow);
   KeepOrder();
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Verify();
 #endif
   return may_overflow;
 }
 
 
 void Range::KeepOrder() {
   if (lower_ > upper_) {
     int32_t tmp = lower_;
     lower_ = upper_;
     upper_ = tmp;
   }
 }
 
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
 void Range::Verify() const {
   DCHECK(lower_ <= upper_);
 }
 #endif
 
 
 bool Range::MulAndCheckOverflow(const Representation& r, Range* other) {
   bool may_overflow = false;
   int v1 = MulWithoutOverflow(r, lower_, other->lower(), &may_overflow);
   int v2 = MulWithoutOverflow(r, lower_, other->upper(), &may_overflow);
   int v3 = MulWithoutOverflow(r, upper_, other->lower(), &may_overflow);
   int v4 = MulWithoutOverflow(r, upper_, other->upper(), &may_overflow);
   lower_ = Min(Min(v1, v2), Min(v3, v4));
   upper_ = Max(Max(v1, v2), Max(v3, v4));
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Verify();
 #endif
   return may_overflow;
 }
 
 
 bool HValue::IsDefinedAfter(HBasicBlock* other) const {
   return block()->block_id() > other->block_id();
 }
 
@@ skipping 408 matching lines @@
   // should precede the other one in order to dominate it.
   for (HInstruction* instr = next(); instr != NULL; instr = instr->next()) {
     if (instr == other) {
       return true;
     }
   }
   return false;
 }
 
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
 void HInstruction::Verify() {
   // Verify that input operands are defined before use.
   HBasicBlock* cur_block = block();
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* other_operand = OperandAt(i);
     if (other_operand == NULL) continue;
     HBasicBlock* other_block = other_operand->block();
     if (cur_block == other_block) {
       if (!other_operand->IsPhi()) {
         HInstruction* cur = this->previous();
@@ skipping 3793 matching lines @@
     if (!use_rep.IsNone() &&
         !use_rep.IsSmi() &&
         !use_rep.IsTagged()) {
       return true;
     }
   }
   return false;
 }
 
 
-// Node-specific verification code is only included in debug mode.
-#ifdef DEBUG
+// Node-specific verification code is only included when DCHECKs are enabled.
+#if DCHECK_IS_ON
 
 void HPhi::Verify() {
   DCHECK(OperandCount() == block()->predecessors()->length());
   for (int i = 0; i < OperandCount(); ++i) {
     HValue* value = OperandAt(i);
     HBasicBlock* defining_block = value->block();
     HBasicBlock* predecessor_block = block()->predecessors()->at(i);
     DCHECK(defining_block == predecessor_block ||
            defining_block->Dominates(predecessor_block));
   }
@@ skipping 234 matching lines @@
       break;
     case HObjectAccess::kExternalMemory:
       os << "[external-memory]";
       break;
   }
 
   return os << "@" << access.offset();
 }
 
 } }  // namespace v8::internal