Add support for enabling DCHECKs in release mode

src/hydrogen.cc

 // Copyright 2013 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/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 158 matching lines @@
   HEnvironment* environment = last_environment();
   DCHECK(ast_id.IsNone() ||
          ast_id == BailoutId::StubEntry() ||
          environment->closure()->shared()->VerifyBailoutId(ast_id));
 
   int push_count = environment->push_count();
   int pop_count = environment->pop_count();
 
   HSimulate* instr =
       new(zone()) HSimulate(ast_id, pop_count, zone(), removable);
-#ifdef DEBUG
+#if DCHECK_IS_ON
   instr->set_closure(environment->closure());
 #endif
   // Order of pushed values: newest (top of stack) first. This allows
   // HSimulate::MergeWith() to easily append additional pushed values
   // that are older (from further down the stack).
   for (int i = 0; i < push_count; ++i) {
     instr->AddPushedValue(environment->ExpressionStackAt(i));
   }
   for (GrowableBitVector::Iterator it(environment->assigned_variables(),
                                       zone());
@@ skipping 265 matching lines @@
 
 int HBasicBlock::PredecessorIndexOf(HBasicBlock* predecessor) const {
   for (int i = 0; i < predecessors_.length(); ++i) {
     if (predecessors_[i] == predecessor) return i;
   }
   UNREACHABLE();
   return -1;
 }
 
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
 void HBasicBlock::Verify() {
   // Check that every block is finished.
   DCHECK(IsFinished());
   DCHECK(block_id() >= 0);
 
   // Check that the incoming edges are in edge split form.
   if (predecessors_.length() > 1) {
     for (int i = 0; i < predecessors_.length(); ++i) {
       DCHECK(predecessors_[i]->end()->SecondSuccessor() == NULL);
     }
@@ skipping 30 matching lines @@
   } else {
     block->set_parent_loop_header(loop_header());
     blocks_.Add(block, block->zone());
     for (int i = 0; i < block->predecessors()->length(); ++i) {
       AddBlock(block->predecessors()->at(i));
     }
   }
 }
 
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
 
 // Checks reachability of the blocks in this graph and stores a bit in
 // the BitVector "reachable()" for every block that can be reached
 // from the start block of the graph. If "dont_visit" is non-null, the given
 // block is treated as if it would not be part of the graph. "visited_count()"
 // returns the number of reachable blocks.
 class ReachabilityAnalyzer BASE_EMBEDDED {
  public:
   ReachabilityAnalyzer(HBasicBlock* entry_block,
                        int block_count,
@@ skipping 3317 matching lines @@
   HBasicBlock* loop_header_;
   int loop_index;
   int loop_length;
   HSuccessorIterator successor_iterator;
 };
 
 
 void HGraph::OrderBlocks() {
   CompilationPhase phase("H_Block ordering", info());
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   // Initially the blocks must not be ordered.
   for (int i = 0; i < blocks_.length(); ++i) {
     DCHECK(!blocks_[i]->IsOrdered());
   }
 #endif
 
   PostorderProcessor* postorder =
       PostorderProcessor::CreateEntryProcessor(zone(), blocks_[0]);
   blocks_.Rewind(0);
   while (postorder) {
     postorder = postorder->PerformStep(zone(), &blocks_);
   }
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   // Now all blocks must be marked as ordered.
   for (int i = 0; i < blocks_.length(); ++i) {
     DCHECK(blocks_[i]->IsOrdered());
   }
 #endif
 
   // Reverse block list and assign block IDs.
   for (int i = 0, j = blocks_.length(); --j >= i; ++i) {
     HBasicBlock* bi = blocks_[i];
     HBasicBlock* bj = blocks_[j];
@@ skipping 128 matching lines @@
 
 
 // Implementation of utility classes to represent an expression's context in
 // the AST.
 AstContext::AstContext(HOptimizedGraphBuilder* owner, Expression::Context kind)
     : owner_(owner),
       kind_(kind),
       outer_(owner->ast_context()),
       for_typeof_(false) {
   owner->set_ast_context(this);  // Push.
-#ifdef DEBUG
+#if DCHECK_IS_ON
   DCHECK(owner->environment()->frame_type() == JS_FUNCTION);
   original_length_ = owner->environment()->length();
 #endif
 }
 
 
 AstContext::~AstContext() {
   owner_->set_ast_context(outer_);  // Pop.
 }
 
@@ skipping 340 matching lines @@
 bool HGraph::Optimize(BailoutReason* bailout_reason) {
   OrderBlocks();
   AssignDominators();
 
   // We need to create a HConstant "zero" now so that GVN will fold every
   // zero-valued constant in the graph together.
   // The constant is needed to make idef-based bounds check work: the pass
   // evaluates relations with "zero" and that zero cannot be created after GVN.
   GetConstant0();
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   // Do a full verify after building the graph and computing dominators.
   Verify(true);
 #endif
 
   if (FLAG_analyze_environment_liveness && maximum_environment_size() != 0) {
     Run<HEnvironmentLivenessAnalysisPhase>();
   }
 
   if (!CheckConstPhiUses()) {
     *bailout_reason = kUnsupportedPhiUseOfConstVariable;
@@ skipping 64 matching lines @@
   return true;
 }
 
 
 void HGraph::RestoreActualValues() {
   HPhase phase("H_Restore actual values", this);
 
   for (int block_index = 0; block_index < blocks()->length(); block_index++) {
     HBasicBlock* block = blocks()->at(block_index);
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
     for (int i = 0; i < block->phis()->length(); i++) {
       HPhi* phi = block->phis()->at(i);
       DCHECK(phi->ActualValue() == phi);
     }
 #endif
 
     for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
       HInstruction* instruction = it.Current();
       if (instruction->ActualValue() == instruction) continue;
       if (instruction->CheckFlag(HValue::kIsDead)) {
@@ skipping 8539 matching lines @@
   times_.Add(time);
   sizes_.Add(size);
 }
 
 
 HPhase::~HPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal