Add support for enabling DCHECKs in release mode

src/objects-debug.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/disasm.h"
 #include "src/disassembler.h"
 #include "src/heap/objects-visiting.h"
 #include "src/jsregexp.h"
@@ skipping 1051 matching lines @@
 
 void BreakPointInfo::BreakPointInfoVerify() {
   CHECK(IsBreakPointInfo());
   code_position()->SmiVerify();
   source_position()->SmiVerify();
   statement_position()->SmiVerify();
   VerifyPointer(break_point_objects());
 }
 #endif  // VERIFY_HEAP
 
-#ifdef DEBUG
+#if DCHECK_IS_ON
 
 void JSObject::IncrementSpillStatistics(SpillInformation* info) {
   info->number_of_objects_++;
   // Named properties
   if (HasFastProperties()) {
     info->number_of_objects_with_fast_properties_++;
     info->number_of_fast_used_fields_   += map()->NextFreePropertyIndex();
     info->number_of_fast_unused_fields_ += map()->unused_property_fields();
   } else {
     NameDictionary* dict = property_dictionary();
@@ skipping 84 matching lines @@
 }
 
 
 bool DescriptorArray::IsSortedNoDuplicates(int valid_entries) {
   if (valid_entries == -1) valid_entries = number_of_descriptors();
   Name* current_key = NULL;
   uint32_t current = 0;
   for (int i = 0; i < number_of_descriptors(); i++) {
     Name* key = GetSortedKey(i);
     if (key == current_key) {
+#ifdef OBJECT_PRINT
       OFStream os(stdout);
       PrintDescriptors(os);
+#endif
       return false;
     }
     current_key = key;
     uint32_t hash = GetSortedKey(i)->Hash();
     if (hash < current) {
+#ifdef OBJECT_PRINT
       OFStream os(stdout);
       PrintDescriptors(os);
+#endif
       return false;
     }
     current = hash;
   }
   return true;
 }
 
 
+#ifdef ENABLE_SLOW_DCHECKS
 bool LayoutDescriptor::IsConsistentWithMap(Map* map) {
   if (FLAG_unbox_double_fields) {
     DescriptorArray* descriptors = map->instance_descriptors();
     int nof_descriptors = map->NumberOfOwnDescriptors();
     for (int i = 0; i < nof_descriptors; i++) {
       PropertyDetails details = descriptors->GetDetails(i);
       if (details.type() != FIELD) continue;
       FieldIndex field_index = FieldIndex::ForDescriptor(map, i);
       bool tagged_expected =
           !field_index.is_inobject() || !details.representation().IsDouble();
       for (int bit = 0; bit < details.field_width_in_words(); bit++) {
         bool tagged_actual = IsTagged(details.field_index() + bit);
         DCHECK_EQ(tagged_expected, tagged_actual);
         if (tagged_actual != tagged_expected) return false;
       }
     }
   }
   return true;
 }
+#endif
 
 
 bool TransitionArray::IsSortedNoDuplicates(int valid_entries) {
   DCHECK(valid_entries == -1);
   Name* current_key = NULL;
   uint32_t current = 0;
   for (int i = 0; i < number_of_transitions(); i++) {
     Name* key = GetSortedKey(i);
     if (key == current_key) {
+#ifdef OBJECT_PRINT
       OFStream os(stdout);
       PrintTransitions(os);
+#endif
       return false;
     }
     current_key = key;
     uint32_t hash = GetSortedKey(i)->Hash();
     if (hash < current) {
+#ifdef OBJECT_PRINT
       OFStream os(stdout);
       PrintTransitions(os);
+#endif
       return false;
     }
     current = hash;
   }
   return true;
 }
 
 
 static bool CheckOneBackPointer(Map* current_map, Object* target) {
   return !target->IsMap() || Map::cast(target)->GetBackPointer() == current_map;
 }
 
 
 bool TransitionArray::IsConsistentWithBackPointers(Map* current_map) {
   for (int i = 0; i < number_of_transitions(); ++i) {
     if (!CheckOneBackPointer(current_map, GetTarget(i))) return false;
   }
   return true;
 }
 
+#endif  // DCHECK_IS_ON
+
+#ifdef DEBUG
 
 void Code::VerifyEmbeddedObjectsInFullCode() {
   // Check that no context-specific object has been embedded.
   Heap* heap = GetIsolate()->heap();
   int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   for (RelocIterator it(this, mask); !it.done(); it.next()) {
     Object* obj = it.rinfo()->target_object();
     if (obj->IsCell()) obj = Cell::cast(obj)->value();
     if (obj->IsPropertyCell()) obj = PropertyCell::cast(obj)->value();
     if (!obj->IsHeapObject()) continue;
     Map* map = obj->IsMap() ? Map::cast(obj) : HeapObject::cast(obj)->map();
     int i = 0;
     while (map != heap->roots_array_start()[i++]) {
       CHECK_LT(i, Heap::kStrongRootListLength);
     }
   }
 }
 
-
 #endif  // DEBUG
 
 } }  // namespace v8::internal