Enable --verify-heap in release mode

src/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 313 matching lines @@
 
 
 void Heap::PrintShortHeapStatistics() {
   if (!FLAG_trace_gc_verbose) return;
   PrintPID("Memory allocator,   used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB\n",
            isolate_->memory_allocator()->Size() / KB,
            isolate_->memory_allocator()->Available() / KB);
   PrintPID("New space,          used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            new_space_.Size() / KB,
            new_space_.Available() / KB,
-           new_space_.CommittedMemory() / KB);
+           new_space_.CommittedMemory() / KB,
+           new_space_.bottom());

[mvstanton1, 2012/10/11 12:22:45]

oops, should not have checked in this debugging code.

   PrintPID("Old pointers,       used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            old_pointer_space_->SizeOfObjects() / KB,
            old_pointer_space_->Available() / KB,
-           old_pointer_space_->CommittedMemory() / KB);
+           old_pointer_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(
+               old_pointer_space_->FirstPage()->address()));
   PrintPID("Old data space,     used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            old_data_space_->SizeOfObjects() / KB,
            old_data_space_->Available() / KB,
-           old_data_space_->CommittedMemory() / KB);
+           old_data_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(old_data_space_->FirstPage()->address()));
   PrintPID("Code space,         used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            code_space_->SizeOfObjects() / KB,
            code_space_->Available() / KB,
-           code_space_->CommittedMemory() / KB);
+           code_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(code_space_->FirstPage()->address()));
   PrintPID("Map space,          used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            map_space_->SizeOfObjects() / KB,
            map_space_->Available() / KB,
-           map_space_->CommittedMemory() / KB);
+           map_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(map_space_->FirstPage()->address()));
   PrintPID("Cell space,         used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            cell_space_->SizeOfObjects() / KB,
            cell_space_->Available() / KB,
-           cell_space_->CommittedMemory() / KB);
+           cell_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(cell_space_->FirstPage()->address()));
   PrintPID("Large object space, used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
-               ", committed: %6" V8_PTR_PREFIX "d KB\n",
+               ", committed: %6" V8_PTR_PREFIX "d KB"
+               ", %p\n",
            lo_space_->SizeOfObjects() / KB,
            lo_space_->Available() / KB,
-           lo_space_->CommittedMemory() / KB);
+           lo_space_->CommittedMemory() / KB,
+           reinterpret_cast<void *>(lo_space_->first_page()->address()));
   PrintPID("All spaces,         used: %6" V8_PTR_PREFIX "d KB"
                ", available: %6" V8_PTR_PREFIX "d KB"
                ", committed: %6" V8_PTR_PREFIX "d KB\n",
            this->SizeOfObjects() / KB,
            this->Available() / KB,
            this->CommittedMemory() / KB);
   PrintPID("Total time spent in GC  : %d ms\n", total_gc_time_ms_);
 }
 
 
@@ skipping 13 matching lines @@
   if (FLAG_log_gc) new_space_.ReportStatistics();
 #endif  // DEBUG
 }
 
 
 void Heap::GarbageCollectionPrologue() {
   isolate_->transcendental_cache()->Clear();
   ClearJSFunctionResultCaches();
   gc_count_++;
   unflattened_strings_length_ = 0;
-#ifdef DEBUG
-  ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
-  allow_allocation(false);
 
   if (FLAG_verify_heap) {
     Verify();
   }
 
+#ifdef DEBUG
+  ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
+  allow_allocation(false);
+
   if (FLAG_gc_verbose) Print();
 #endif  // DEBUG
 
 #if defined(DEBUG)
   ReportStatisticsBeforeGC();
 #endif  // DEBUG
 
   LiveObjectList::GCPrologue();
   store_buffer()->GCPrologue();
 }
@@ skipping 15 matching lines @@
        space != NULL;
        space = spaces.next()) {
     space->RepairFreeListsAfterBoot();
   }
 }
 
 
 void Heap::GarbageCollectionEpilogue() {
   store_buffer()->GCEpilogue();
   LiveObjectList::GCEpilogue();
+
 #ifdef DEBUG
   allow_allocation(true);

[Michael Starzinger, 2012/10/11 12:42:46]

Neither the zapping nor the verification should do any allocation, so we can
move this down right before the printing calls I think.

[mvstanton1, 2012/10/12 08:40:50]

Done.

-  ZapFromSpace();
+#endif
+
+  // In release mode, we only zap the from space under heap verification.
+#ifndef DEBUG
+  if (FLAG_verify_heap) {
+#endif
+    ZapFromSpace();
+#ifndef DEBUG
+  }
+#endif
 
   if (FLAG_verify_heap) {
     Verify();
   }
 
+#ifdef DEBUG
   if (FLAG_print_global_handles) isolate_->global_handles()->Print();
   if (FLAG_print_handles) PrintHandles();
   if (FLAG_gc_verbose) Print();
   if (FLAG_code_stats) ReportCodeStatistics("After GC");
 #endif
 
   isolate_->counters()->alive_after_last_gc()->Set(
       static_cast<int>(SizeOfObjects()));
 
   isolate_->counters()->symbol_table_capacity()->Set(
@@ skipping 176 matching lines @@
 void Heap::PerformScavenge() {
   GCTracer tracer(this, NULL, NULL);
   if (incremental_marking()->IsStopped()) {
     PerformGarbageCollection(SCAVENGER, &tracer);
   } else {
     PerformGarbageCollection(MARK_COMPACTOR, &tracer);
   }
 }
 
 
-#ifdef DEBUG
 // Helper class for verifying the symbol table.
 class SymbolTableVerifier : public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
       if ((*p)->IsHeapObject()) {
         // Check that the symbol is actually a symbol.
-        ASSERT((*p)->IsTheHole() || (*p)->IsUndefined() || (*p)->IsSymbol());
+        CHECK((*p)->IsTheHole() || (*p)->IsUndefined() || (*p)->IsSymbol());
       }
     }
   }
 };
-#endif  // DEBUG
 
 
 static void VerifySymbolTable() {
-#ifdef DEBUG
   SymbolTableVerifier verifier;
   HEAP->symbol_table()->IterateElements(&verifier);
-#endif  // DEBUG
 }
 
 
 static bool AbortIncrementalMarkingAndCollectGarbage(
     Heap* heap,
     AllocationSpace space,
     const char* gc_reason = NULL) {
   heap->mark_compact_collector()->SetFlags(Heap::kAbortIncrementalMarkingMask);
   bool result = heap->CollectGarbage(space, gc_reason);
   heap->mark_compact_collector()->SetFlags(Heap::kNoGCFlags);
@@ skipping 351 matching lines @@
     Object* object = *p;
     if (!heap_->InNewSpace(object)) return;
     Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
                          reinterpret_cast<HeapObject*>(object));
   }
 
   Heap* heap_;
 };
 
 
-#ifdef DEBUG
 // Visitor class to verify pointers in code or data space do not point into
 // new space.
 class VerifyNonPointerSpacePointersVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object**end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
-        ASSERT(!HEAP->InNewSpace(HeapObject::cast(*current)));
+        CHECK(!HEAP->InNewSpace(HeapObject::cast(*current)));
       }
     }
   }
 };
 
 
 static void VerifyNonPointerSpacePointers() {
   // Verify that there are no pointers to new space in spaces where we
   // do not expect them.
   VerifyNonPointerSpacePointersVisitor v;
   HeapObjectIterator code_it(HEAP->code_space());
   for (HeapObject* object = code_it.Next();
        object != NULL; object = code_it.Next())
     object->Iterate(&v);
 
   // The old data space was normally swept conservatively so that the iterator
   // doesn't work, so we normally skip the next bit.
   if (!HEAP->old_data_space()->was_swept_conservatively()) {
     HeapObjectIterator data_it(HEAP->old_data_space());
     for (HeapObject* object = data_it.Next();
          object != NULL; object = data_it.Next())
       object->Iterate(&v);
   }
 }
-#endif
 
 
 void Heap::CheckNewSpaceExpansionCriteria() {
   if (new_space_.Capacity() < new_space_.MaximumCapacity() &&
       survived_since_last_expansion_ > new_space_.Capacity() &&
       !new_space_high_promotion_mode_active_) {
     // Grow the size of new space if there is room to grow, enough data
     // has survived scavenge since the last expansion and we are not in
     // high promotion mode.
     new_space_.Grow();
@@ skipping 118 matching lines @@
     return NULL;
   }
 
  private:
   Heap* heap_;
 };
 
 
 void Heap::Scavenge() {
   RelocationLock relocation_lock(this);
-#ifdef DEBUG
+
   if (FLAG_verify_heap) VerifyNonPointerSpacePointers();
-#endif
 
   gc_state_ = SCAVENGE;
 
   // Implements Cheney's copying algorithm
   LOG(isolate_, ResourceEvent("scavenge", "begin"));
 
   // Clear descriptor cache.
   isolate_->descriptor_lookup_cache()->Clear();
 
   // Used for updating survived_since_last_expansion_ at function end.
@@ skipping 3358 matching lines @@
   { MaybeObject* maybe_result = AllocateRaw(size, space, retry_space);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
 
   // Partially initialize the object.
   HeapObject::cast(result)->set_map_no_write_barrier(ascii_string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
   ASSERT_EQ(size, HeapObject::cast(result)->Size());
 
-#ifdef DEBUG
   if (FLAG_verify_heap) {
     // Initialize string's content to ensure ASCII-ness (character range 0-127)
     // as required when verifying the heap.
     char* dest = SeqAsciiString::cast(result)->GetChars();
     memset(dest, 0x0F, length * kCharSize);
   }
-#endif  // DEBUG
 
   return result;
 }
 
 
 MaybeObject* Heap::AllocateRawTwoByteString(int length,
                                             PretenureFlag pretenure) {
   if (length < 0 || length > SeqTwoByteString::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
@@ skipping 64 matching lines @@
 
 MaybeObject* Heap::AllocateRawFixedArray(int length) {
   if (length < 0 || length > FixedArray::kMaxLength) {
     return Failure::OutOfMemoryException();
   }
   ASSERT(length > 0);
   // Use the general function if we're forced to always allocate.
   if (always_allocate()) return AllocateFixedArray(length, TENURED);
   // Allocate the raw data for a fixed array.
   int size = FixedArray::SizeFor(length);
-  return size <= kMaxObjectSizeInNewSpace
-      ? new_space_.AllocateRaw(size)
-      : lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
+  MaybeObject* retptr;

[mvstanton1, 2012/10/11 12:22:45]

I think this was debugging, I will revert this block.

+  if (size <= kMaxObjectSizeInNewSpace) {
+    retptr = new_space_.AllocateRaw(size);
+  } else {
+    retptr = lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
+  }
+
+  return retptr;
 }
 
 
 MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) {
   int len = src->length();
   Object* obj;
   { MaybeObject* maybe_obj = AllocateRawFixedArray(len);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
   if (InNewSpace(obj)) {
@@ skipping 682 matching lines @@
     case CELL_SPACE:
       return cell_space_->Contains(addr);
     case LO_SPACE:
       return lo_space_->SlowContains(addr);
   }
 
   return false;
 }
 
 
-#ifdef DEBUG
 void Heap::Verify() {
-  ASSERT(HasBeenSetUp());
+  CHECK(HasBeenSetUp());
 
   store_buffer()->Verify();
 
   VerifyPointersVisitor visitor;
   IterateRoots(&visitor, VISIT_ONLY_STRONG);
 
   new_space_.Verify();
 
   old_pointer_space_->Verify(&visitor);
   map_space_->Verify(&visitor);
 
   VerifyPointersVisitor no_dirty_regions_visitor;
   old_data_space_->Verify(&no_dirty_regions_visitor);
   code_space_->Verify(&no_dirty_regions_visitor);
   cell_space_->Verify(&no_dirty_regions_visitor);
 
   lo_space_->Verify();
 }
 
-
-#endif  // DEBUG
-
-
 MaybeObject* Heap::LookupSymbol(Vector<const char> string) {
   Object* symbol = NULL;
   Object* new_table;
   { MaybeObject* maybe_new_table =
         symbol_table()->LookupSymbol(string, &symbol);
     if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
   }
   // Can't use set_symbol_table because SymbolTable::cast knows that
   // SymbolTable is a singleton and checks for identity.
   roots_[kSymbolTableRootIndex] = new_table;
@@ skipping 69 matching lines @@
 
 
 bool Heap::LookupSymbolIfExists(String* string, String** symbol) {
   if (string->IsSymbol()) {
     *symbol = string;
     return true;
   }
   return symbol_table()->LookupSymbolIfExists(string, symbol);
 }
 
-
-#ifdef DEBUG
 void Heap::ZapFromSpace() {
   NewSpacePageIterator it(new_space_.FromSpaceStart(),
                           new_space_.FromSpaceEnd());
   while (it.has_next()) {
     NewSpacePage* page = it.next();
     for (Address cursor = page->area_start(), limit = page->area_end();
          cursor < limit;
          cursor += kPointerSize) {
       Memory::Address_at(cursor) = kFromSpaceZapValue;
     }
   }
 }
-#endif  // DEBUG
 
 
 void Heap::IterateAndMarkPointersToFromSpace(Address start,
                                              Address end,
                                              ObjectSlotCallback callback) {
   Address slot_address = start;
 
   // We are not collecting slots on new space objects during mutation
   // thus we have to scan for pointers to evacuation candidates when we
   // promote objects. But we should not record any slots in non-black
@@ skipping 716 matching lines @@
   roots_[kStackLimitRootIndex] =
       reinterpret_cast<Object*>(
           (isolate_->stack_guard()->jslimit() & ~kSmiTagMask) | kSmiTag);
   roots_[kRealStackLimitRootIndex] =
       reinterpret_cast<Object*>(
           (isolate_->stack_guard()->real_jslimit() & ~kSmiTagMask) | kSmiTag);
 }
 
 
 void Heap::TearDown() {
-#ifdef DEBUG
   if (FLAG_verify_heap) {
     Verify();
   }
-#endif
+
   if (FLAG_print_cumulative_gc_stat) {
     PrintF("\n\n");
     PrintF("gc_count=%d ", gc_count_);
     PrintF("mark_sweep_count=%d ", ms_count_);
     PrintF("max_gc_pause=%d ", get_max_gc_pause());
     PrintF("total_gc_time=%d ", total_gc_time_ms_);
     PrintF("min_in_mutator=%d ", get_min_in_mutator());
     PrintF("max_alive_after_gc=%" V8_PTR_PREFIX "d ",
            get_max_alive_after_gc());
     PrintF("\n\n");
@@ skipping 1049 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal