Enable --verify-heap in release mode

src/spaces.h

 // Copyright 2011 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 1556 matching lines @@
 
   // Releases an unused page and shrinks the space.
   void ReleasePage(Page* page);
 
   // Releases all of the unused pages.
   void ReleaseAllUnusedPages();
 
   // The dummy page that anchors the linked list of pages.
   Page* anchor() { return &anchor_; }
 
+#ifdef VERIFY_HEAP
+  // Verify integrity of this space.
+  virtual void Verify(ObjectVisitor* visitor);
+
+  // Overridden by subclasses to verify space-specific object
+  // properties (e.g., only maps or free-list nodes are in map space).
+  virtual void VerifyObject(HeapObject* obj) {}
+#endif
+
 #ifdef DEBUG
   // Print meta info and objects in this space.
   virtual void Print();
 
-  // Verify integrity of this space.
-  virtual void Verify(ObjectVisitor* visitor);
-
   // Reports statistics for the space
   void ReportStatistics();
 
-  // Overridden by subclasses to verify space-specific object
-  // properties (e.g., only maps or free-list nodes are in map space).
-  virtual void VerifyObject(HeapObject* obj) {}
-
   // Report code object related statistics
   void CollectCodeStatistics();
   static void ReportCodeStatistics();
   static void ResetCodeStatistics();
 #endif
 
   bool was_swept_conservatively() { return was_swept_conservatively_; }
   void set_was_swept_conservatively(bool b) { was_swept_conservatively_ = b; }
 
   // Evacuation candidates are swept by evacuator.  Needs to return a valid
@@ skipping 326 matching lines @@
     return false;
   }
 
   bool is_committed() { return committed_; }
   bool Commit();
   bool Uncommit();
 
   NewSpacePage* first_page() { return anchor_.next_page(); }
   NewSpacePage* current_page() { return current_page_; }
 
+#ifdef VERIFY_HEAP
+  virtual void Verify();
+#endif
+
 #ifdef DEBUG
   virtual void Print();
-  virtual void Verify();
   // Validate a range of of addresses in a SemiSpace.
   // The "from" address must be on a page prior to the "to" address,
   // in the linked page order, or it must be earlier on the same page.
   static void AssertValidRange(Address from, Address to);
 #else
   // Do nothing.
   inline static void AssertValidRange(Address from, Address to) {}
 #endif
 
   // Returns the current capacity of the semi space.
@@ skipping 304 matching lines @@
   // if successful.
   bool AddFreshPage();
 
   virtual bool ReserveSpace(int bytes);
 
   // Resizes a sequential string which must be the most recent thing that was
   // allocated in new space.
   template <typename StringType>
   inline void ShrinkStringAtAllocationBoundary(String* string, int len);
 
-#ifdef DEBUG
+#ifdef VERIFY_HEAP
   // Verify the active semispace.
   virtual void Verify();
+#endif
+
+#ifdef DEBUG
   // Print the active semispace.
   virtual void Print() { to_space_.Print(); }
 #endif
 
   // Iterates the active semispace to collect statistics.
   void CollectStatistics();
   // Reports previously collected statistics of the active semispace.
   void ReportStatistics();
   // Clears previously collected statistics.
   void ClearHistograms();
@@ skipping 149 matching lines @@
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(Map::kSize)) {
       return RoundDown(size, Map::kSize);
     } else {
       return (size / Map::kSize) * Map::kSize;
     }
   }
 
  protected:
-#ifdef DEBUG
   virtual void VerifyObject(HeapObject* obj);
-#endif
 
  private:
   static const int kMapsPerPage = Page::kNonCodeObjectAreaSize / Map::kSize;
 
   // Do map space compaction if there is a page gap.
   int CompactionThreshold() {
     return kMapsPerPage * (max_map_space_pages_ - 1);
   }
 
   const int max_map_space_pages_;
@@ skipping 15 matching lines @@
 
   virtual int RoundSizeDownToObjectAlignment(int size) {
     if (IsPowerOf2(JSGlobalPropertyCell::kSize)) {
       return RoundDown(size, JSGlobalPropertyCell::kSize);
     } else {
       return (size / JSGlobalPropertyCell::kSize) * JSGlobalPropertyCell::kSize;
     }
   }
 
  protected:
-#ifdef DEBUG
   virtual void VerifyObject(HeapObject* obj);
-#endif
 
  public:
   TRACK_MEMORY("CellSpace")
 };
 
 
 // -----------------------------------------------------------------------------
 // Large objects ( > Page::kMaxHeapObjectSize ) are allocated and managed by
 // the large object space. A large object is allocated from OS heap with
 // extra padding bytes (Page::kPageSize + Page::kObjectStartOffset).
@@ skipping 58 matching lines @@
   // Checks whether the space is empty.
   bool IsEmpty() { return first_page_ == NULL; }
 
   // See the comments for ReserveSpace in the Space class.  This has to be
   // called after ReserveSpace has been called on the paged spaces, since they
   // may use some memory, leaving less for large objects.
   virtual bool ReserveSpace(int bytes);
 
   LargePage* first_page() { return first_page_; }
 
+#ifdef VERIFY_HEAP
+  virtual void Verify();
+#endif
+
 #ifdef DEBUG
-  virtual void Verify();
   virtual void Print();
   void ReportStatistics();
   void CollectCodeStatistics();
 #endif
   // Checks whether an address is in the object area in this space.  It
   // iterates all objects in the space. May be slow.
   bool SlowContains(Address addr) { return !FindObject(addr)->IsFailure(); }
 
  private:
   intptr_t max_capacity_;
@@ skipping 101 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_