Add support for enabling DCHECKs in release mode

src/lithium-allocator.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/hydrogen.h"
 #include "src/lithium-inl.h"
 #include "src/lithium-allocator-inl.h"
 #include "src/string-stream.h"
@@ skipping 47 matching lines @@
 
 void UseInterval::SplitAt(LifetimePosition pos, Zone* zone) {
   DCHECK(Contains(pos) && pos.Value() != start().Value());
   UseInterval* after = new(zone) UseInterval(pos, end_);
   after->next_ = next_;
   next_ = after;
   end_ = pos;
 }
 
 
 #ifdef DEBUG

[Jakob Kummerow, 2014/12/03 10:53:53]

forgotten?

 
 
 void LiveRange::Verify() const {
   UsePosition* cur = first_pos_;
   while (cur != NULL) {
     DCHECK(Start().Value() <= cur->pos().Value() &&
            cur->pos().Value() <= End().Value());
     cur = cur->next();
   }
 }
 
 
 bool LiveRange::HasOverlap(UseInterval* target) const {

[Jakob Kummerow, 2014/12/03 10:53:53]

This is dead code. Delete it while you're here, along with its declaration in
the header file. Please also delete the copy in
compiler/register-allocator.{h,cc}.

   UseInterval* current_interval = first_interval_;
   while (current_interval != NULL) {
     // Intervals overlap if the start of one is contained in the other.
     if (current_interval->Contains(target->start()) ||
         target->Contains(current_interval->start())) {
       return true;
     }
     current_interval = current_interval->next();
   }
   return false;
@@ skipping 1231 matching lines @@
         LiveRange* range = LiveRangeFor(operand_index);
         range->EnsureInterval(start, end, zone());
         iterator.Advance();
       }
 
       for (int i = block->block_id() + 1; i <= back_edge->block_id(); ++i) {
         live_in_sets_[i]->Union(*live);
       }
     }
 
 #ifdef DEBUG

[Jakob Kummerow, 2014/12/03 10:53:53]

forgotten?

     if (block_id == 0) {
       BitVector::Iterator iterator(live);
       bool found = false;
       while (!iterator.Done()) {
         found = true;
         int operand_index = iterator.Current();
         if (chunk_->info()->IsStub()) {
           CodeStub::Major major_key = chunk_->info()->code_stub()->MajorKey();
           PrintF("Function: %s\n", CodeStub::MajorName(major_key, false));
         } else {
@@ skipping 168 matching lines @@
         AddToInactive(current);
       }
     }
   }
 
   while (!unhandled_live_ranges_.is_empty()) {
     DCHECK(UnhandledIsSorted());
     LiveRange* current = unhandled_live_ranges_.RemoveLast();
     DCHECK(UnhandledIsSorted());
     LifetimePosition position = current->Start();
-#ifdef DEBUG
+#if DCHECK_IS_ON
     allocation_finger_ = position;
 #endif
     TraceAlloc("Processing interval %d start=%d\n",
                current->id(),
                position.Value());
 
     if (current->HasAllocatedSpillOperand()) {
       TraceAlloc("Live range %d already has a spill operand\n", current->id());
       LifetimePosition next_pos = position;
       if (IsGapAt(next_pos.InstructionIndex())) {
@@ skipping 609 matching lines @@
   }
   range->MakeSpilled(chunk()->zone());
 }
 
 
 int LAllocator::RegisterCount() const {
   return num_registers_;
 }
 
 
 #ifdef DEBUG

[Jakob Kummerow, 2014/12/03 10:53:53]

forgotten?

 
 
 void LAllocator::Verify() const {
   for (int i = 0; i < live_ranges()->length(); ++i) {
     LiveRange* current = live_ranges()->at(i);
     if (current != NULL) current->Verify();
   }
 }
 
 
@@ skipping 15 matching lines @@
     unsigned size = allocator_->zone()->allocation_size() -
                     allocator_zone_start_allocation_size_;
     isolate()->GetHStatistics()->SaveTiming(name(), base::TimeDelta(), size);
   }
 
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), allocator_->chunk());
     isolate()->GetHTracer()->TraceLiveRanges(name(), allocator_);
   }
 
 #ifdef DEBUG

[Jakob Kummerow, 2014/12/03 10:53:53]

forgotten?

   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 
 } }  // namespace v8::internal