Add support for enabling DCHECKs in release mode

src/hydrogen-instructions.h

 // 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.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include <iosfwd>
 
 #include "src/v8.h"
@@ skipping 241 matching lines @@
     return lower_ == kMinInt && upper_ == kMaxInt && CanBeMinusZero();
   }
   bool IsInSmiRange() const {
     return lower_ >= Smi::kMinValue && upper_ <= Smi::kMaxValue;
   }
   void ClampToSmi() {
     lower_ = Max(lower_, Smi::kMinValue);
     upper_ = Min(upper_, Smi::kMaxValue);
   }
   void KeepOrder();
-#ifdef DEBUG
+#if DCHECK_IS_ON
   void Verify() const;
 #endif
 
   void StackUpon(Range* other) {
     Intersect(other);
     next_ = other;
   }
 
   void Intersect(Range* other);
   void Union(Range* other);
@@ skipping 279 matching lines @@
   bool IsBitwiseBinaryShift() {
     return IsShl() || IsShr() || IsSar();
   }
 
   explicit HValue(HType type = HType::Tagged())
       : block_(NULL),
         id_(kNoNumber),
         type_(type),
         use_list_(NULL),
         range_(NULL),
-#ifdef DEBUG
+#if DCHECK_IS_ON
         range_poisoned_(false),
 #endif
         flags_(0) {}
   virtual ~HValue() {}
 
   virtual HSourcePosition position() const {
     return HSourcePosition::Unknown();
   }
   virtual HSourcePosition operand_position(int index) const {
     return position();
@@ skipping 159 matching lines @@
   }
 
   Range* range() const {
     DCHECK(!range_poisoned_);
     return range_;
   }
   bool HasRange() const {
     DCHECK(!range_poisoned_);
     return range_ != NULL;
   }
-#ifdef DEBUG
+#if DCHECK_IS_ON
   void PoisonRange() { range_poisoned_ = true; }
 #endif
   void AddNewRange(Range* r, Zone* zone);
   void RemoveLastAddedRange();
   void ComputeInitialRange(Zone* zone);
 
   // Escape analysis helpers.
   virtual bool HasEscapingOperandAt(int index) { return true; }
   virtual bool HasOutOfBoundsAccess(int size) { return false; }
 
@@ skipping 43 matching lines @@
                                          HValue* dominator) {
     UNREACHABLE();
     return false;
   }
 
   // Check if this instruction has some reason that prevents elimination.
   bool CannotBeEliminated() const {
     return HasObservableSideEffects() || !IsDeletable();
   }
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() = 0;
 #endif
 
   virtual bool TryDecompose(DecompositionResult* decomposition) {
     if (RedefinedOperand() != NULL) {
       return RedefinedOperand()->TryDecompose(decomposition);
     } else {
       return false;
     }
   }
@@ skipping 92 matching lines @@
   HBasicBlock* block_;
 
   // The id of this instruction in the hydrogen graph, assigned when first
   // added to the graph. Reflects creation order.
   int id_;
 
   Representation representation_;
   HType type_;
   HUseListNode* use_list_;
   Range* range_;
-#ifdef DEBUG
+#if DCHECK_IS_ON
   bool range_poisoned_;
 #endif
   int flags_;
   GVNFlagSet changes_flags_;
   GVNFlagSet depends_on_flags_;
 
  private:
   virtual bool IsDeletable() const { return false; }
 
   DISALLOW_COPY_AND_ASSIGN(HValue);
@@ skipping 259 matching lines @@
     position_.ensure_storage_for_operand_positions(zone, OperandCount());
     position_.set_operand_position(index, pos);
   }
 
   bool Dominates(HInstruction* other);
   bool CanTruncateToSmi() const { return CheckFlag(kTruncatingToSmi); }
   bool CanTruncateToInt32() const { return CheckFlag(kTruncatingToInt32); }
 
   virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE;
 #endif
 
   bool CanDeoptimize();
 
   virtual bool HasStackCheck() { return false; }
 
   DECLARE_ABSTRACT_INSTRUCTION(Instruction)
 
  protected:
@@ skipping 658 matching lines @@
   void MergeWith(ZoneList<HSimulate*>* list);
   bool is_candidate_for_removal() {
     return RemovableField::decode(bit_field_) == REMOVABLE_SIMULATE;
   }
 
   // Replay effects of this instruction on the given environment.
   void ReplayEnvironment(HEnvironment* env);
 
   DECLARE_CONCRETE_INSTRUCTION(Simulate)
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE;
   void set_closure(Handle<JSFunction> closure) { closure_ = closure; }
   Handle<JSFunction> closure() const { return closure_; }
 #endif
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) OVERRIDE {
     values_[index] = value;
   }
 
@@ skipping 23 matching lines @@
   class RemovableField : public BitField<RemovableSimulate, 0, 1> {};
   class DoneWithReplayField : public BitField<bool, 1, 1> {};
 
   BailoutId ast_id_;
   int pop_count_;
   ZoneList<HValue*> values_;
   ZoneList<int> assigned_indexes_;
   Zone* zone_;
   uint32_t bit_field_;
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Handle<JSFunction> closure_;
 #endif
 };
 
 
 class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
  public:
   enum Kind { BIND, LOOKUP };
 
   DECLARE_INSTRUCTION_FACTORY_P2(HEnvironmentMarker, Kind, int);
 
   Kind kind() const { return kind_; }
   int index() const { return index_; }
   HSimulate* next_simulate() { return next_simulate_; }
   void set_next_simulate(HSimulate* simulate) {
     next_simulate_ = simulate;
   }
 
   virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
     return Representation::None();
   }
 
   virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   void set_closure(Handle<JSFunction> closure) {
     DCHECK(closure_.is_null());
     DCHECK(!closure.is_null());
     closure_ = closure;
   }
   Handle<JSFunction> closure() const { return closure_; }
 #endif
 
   DECLARE_CONCRETE_INSTRUCTION(EnvironmentMarker);
 
  private:
   HEnvironmentMarker(Kind kind, int index)
       : kind_(kind), index_(index), next_simulate_(NULL) { }
 
   Kind kind_;
   int index_;
   HSimulate* next_simulate_;
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   Handle<JSFunction> closure_;
 #endif
 };
 
 
 class HStackCheck FINAL : public HTemplateInstruction<1> {
  public:
   enum Type {
     kFunctionEntry,
     kBackwardsBranch
@@ skipping 926 matching lines @@
     object_ = Unique<HeapObject>(object_.handle());
   }
 
   virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
     return Representation::Tagged();
   }
   virtual std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
 
   virtual HValue* Canonicalize() OVERRIDE;
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE;
 #endif
 
   Unique<HeapObject> object() const { return object_; }
   bool object_in_new_space() const { return object_in_new_space_; }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckValue)
 
  protected:
   virtual bool DataEquals(HValue* other) OVERRIDE {
@@ skipping 115 matching lines @@
   virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
   virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
     return Representation::Tagged();
   }
 
   virtual HType CalculateInferredType() OVERRIDE {
     if (value()->type().IsHeapObject()) return value()->type();
     return HType::HeapObject();
   }
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE;
 #endif
 
   virtual HValue* Canonicalize() OVERRIDE {
     return value()->type().IsHeapObject() ? NULL : this;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
 
  protected:
@@ skipping 280 matching lines @@
     return IsInductionVariable() &&
         induction_variable_data_->limit() != NULL;
   }
   void DetectInductionVariable() {
     DCHECK(induction_variable_data_ == NULL);
     induction_variable_data_ = InductionVariableData::ExaminePhi(this);
   }
 
   virtual std::ostream& PrintTo(std::ostream& os) const OVERRIDE;  // NOLINT
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE;
 #endif
 
   void InitRealUses(int id);
   void AddNonPhiUsesFrom(HPhi* other);
   void AddIndirectUsesTo(int* use_count);
 
   int tagged_non_phi_uses() const {
     return non_phi_uses_[Representation::kTagged];
   }
@@ skipping 371 matching lines @@
       if (other_constant->HasInteger32Value() ||
           other_constant->HasDoubleValue() ||
           other_constant->HasExternalReferenceValue()) {
         return false;
       }
       DCHECK(!object_.handle().is_null());
       return other_constant->object_ == object_;
     }
   }
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
   virtual void Verify() OVERRIDE { }
 #endif
 
   DECLARE_CONCRETE_INSTRUCTION(Constant)
 
  protected:
   virtual Range* InferRange(Zone* zone) OVERRIDE;
 
  private:
   friend class HGraph;
@@ skipping 3917 matching lines @@
 
  private:
   explicit HToFastProperties(HValue* value) : HUnaryOperation(value) {
     set_representation(Representation::Tagged());
     SetChangesFlag(kNewSpacePromotion);
 
     // This instruction is not marked as kChangesMaps, but does
     // change the map of the input operand. Use it only when creating
     // object literals via a runtime call.
     DCHECK(value->IsCallRuntime());
-#ifdef DEBUG
+#if DCHECK_IS_ON
     const Runtime::Function* function = HCallRuntime::cast(value)->function();
     DCHECK(function->function_id == Runtime::kCreateObjectLiteral);
 #endif
   }
 
   virtual bool IsDeletable() const OVERRIDE { return true; }
 };
 
 
 class HDateField FINAL : public HUnaryOperation {
@@ skipping 305 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_