Add support for enabling DCHECKs in release mode

src/hydrogen-flow-engine.h

 // 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.
 
 #ifndef V8_HYDROGEN_FLOW_ENGINE_H_
 #define V8_HYDROGEN_FLOW_ENGINE_H_
 
 #include "src/hydrogen.h"
 #include "src/hydrogen-instructions.h"
 #include "src/zone.h"
@@ skipping 50 matching lines @@
 // doing a fixed-point iteration. Thus the flow engine is guaranteed to visit
 // each block at most twice; once for state, and optionally once for effects.
 //
 // The flow engine requires the State and Effects classes to implement methods
 // like the example NoState and NoEffects above. It's not necessary to provide
 // an effects implementation for local analysis.
 template <class State, class Effects>
 class HFlowEngine {
  public:
   HFlowEngine(HGraph* graph, Zone* zone)
-    : graph_(graph),
-      zone_(zone),
-#if DEBUG
-      pred_counts_(graph->blocks()->length(), zone),
+      : graph_(graph),
+        zone_(zone),
+#if DCHECK_IS_ON
+        pred_counts_(graph->blocks()->length(), zone),
 #endif
-      block_states_(graph->blocks()->length(), zone),
-      loop_effects_(graph->blocks()->length(), zone) {
+        block_states_(graph->blocks()->length(), zone),
+        loop_effects_(graph->blocks()->length(), zone) {
     loop_effects_.AddBlock(NULL, graph_->blocks()->length(), zone);
   }
 
   // Local analysis. Iterates over the instructions in the given block.
   State* AnalyzeOneBlock(HBasicBlock* block, State* state) {
     // Go through all instructions of the current block, updating the state.
     for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
       state = state->Process(it.Current(), zone_);
     }
     return state;
@@ skipping 91 matching lines @@
 
   inline State* StateAt(HBasicBlock* block) {
     return block_states_.at(block->block_id());
   }
 
   inline void SetStateAt(HBasicBlock* block, State* state) {
     block_states_.Set(block->block_id(), state);
   }
 
   inline void InitializeStates() {
-#if DEBUG
+#if DCHECK_IS_ON
     pred_counts_.Rewind(0);
     pred_counts_.AddBlock(0, graph_->blocks()->length(), zone_);
 #endif
     block_states_.Rewind(0);
     block_states_.AddBlock(NULL, graph_->blocks()->length(), zone_);
   }
 
   inline void CheckPredecessorCount(HBasicBlock* block) {
     DCHECK(block->predecessors()->length() == pred_counts_[block->block_id()]);
   }
 
   inline void IncrementPredecessorCount(HBasicBlock* block) {
-#if DEBUG
+#if DCHECK_IS_ON
     pred_counts_[block->block_id()]++;
 #endif
   }
 
   HGraph* graph_;                    // The hydrogen graph.
   Zone* zone_;                       // Temporary zone.
-#if DEBUG
+#if DCHECK_IS_ON
   ZoneList<int> pred_counts_;        // Finished predecessors (by block id).
 #endif
   ZoneList<State*> block_states_;    // Block states (by block id).
   ZoneList<Effects*> loop_effects_;  // Loop effects (by block id).
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_FLOW_ENGINE_H_