ifdefs around LayoutDescriptor::IsConsistenWithMap() removed.

test/cctest/test-unboxed-doubles.cc

 // Copyright 2014 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 <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/compilation-cache.h"
@@ skipping 12 matching lines @@
 
 //
 // Helper functions.
 //
 
 
 static void InitializeVerifiedMapDescriptors(
     Map* map, DescriptorArray* descriptors,
     LayoutDescriptor* layout_descriptor) {
   map->InitializeDescriptors(descriptors, layout_descriptor);
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(layout_descriptor->IsConsistentWithMap(map));
-  }
-#endif
+  CHECK(layout_descriptor->IsConsistentWithMap(map));
 }
 
 
 static Handle<String> MakeString(const char* str) {
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   return factory->InternalizeUtf8String(str);
 }
 
 
@@ skipping 173 matching lines @@
     LayoutDescriptor* layout_desc = *layout_descriptor;
     // Play with the bits but leave it in consistent state with map at the end.
     for (int i = 1; i < kPropsCount - 1; i++) {
       layout_desc = layout_desc->SetTaggedForTesting(i, false);
       CHECK_EQ(false, layout_desc->IsTagged(i));
       layout_desc = layout_desc->SetTaggedForTesting(i, true);
       CHECK_EQ(true, layout_desc->IsTagged(i));
     }
     CHECK(layout_desc->IsSlowLayout());
     CHECK(!layout_desc->IsFastPointerLayout());
-#ifdef VERIFY_HEAP
-    if (FLAG_verify_heap) {
-      DCHECK(layout_descriptor->IsConsistentWithMap(*map));
-    }
-#endif
+    CHECK(layout_descriptor->IsConsistentWithMap(*map));
   }
 }
 
 
 static void TestLayoutDescriptorQueries(int layout_descriptor_length,
                                         int* bit_flip_positions,
                                         int max_sequence_length) {
   Handle<LayoutDescriptor> layout_descriptor = LayoutDescriptor::NewForTesting(
       CcTest::i_isolate(), layout_descriptor_length);
   layout_descriptor_length = layout_descriptor->capacity();
@@ skipping 393 matching lines @@
       bool is_inobject = field_index < map->inobject_properties();
       for (int bit = 0; bit < field_width_in_words; bit++) {
         CHECK_EQ(is_inobject && (kind == PROP_DOUBLE),
                  !layout_descriptor->IsTagged(field_index + bit));
       }
       CHECK(layout_descriptor->IsTagged(next_field_offset));
     }
     map->InitializeDescriptors(*descriptors, *layout_descriptor);
   }
   Handle<LayoutDescriptor> layout_descriptor(map->layout_descriptor(), isolate);
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
-  }
-#endif
+  CHECK(layout_descriptor->IsConsistentWithMap(*map));
   return layout_descriptor;
 }
 
 
 TEST(LayoutDescriptorAppend) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<LayoutDescriptor> layout_descriptor;
@@ skipping 106 matching lines @@
         int field_width_in_words = details.field_width_in_words();
 
         bool is_inobject = field_index < map->inobject_properties();
         for (int bit = 0; bit < field_width_in_words; bit++) {
           CHECK_EQ(is_inobject && details.representation().IsDouble(),
                    !layout_desc->IsTagged(field_index + bit));
         }
         CHECK(layout_desc->IsTagged(field_index + field_width_in_words));
       }
     }
-#ifdef VERIFY_HEAP
-    if (FLAG_verify_heap) {
-      DCHECK(map->layout_descriptor()->IsConsistentWithMap(*map));
-    }
-#endif
+    CHECK(map->layout_descriptor()->IsConsistentWithMap(*map));
   }
 
   Handle<LayoutDescriptor> layout_descriptor(map->GetLayoutDescriptor(),
                                              isolate);
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
-  }
-#endif
+  CHECK(layout_descriptor->IsConsistentWithMap(*map));
   return layout_descriptor;
 }
 
 
 TEST(LayoutDescriptorAppendIfFastOrUseFull) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<LayoutDescriptor> layout_descriptor;
@@ skipping 340 matching lines @@
       Handle<String> name = MakeName("prop", i);
       map = Map::CopyWithField(map, name, any_type, NONE, Representation::Smi(),
                                INSERT_TRANSITION).ToHandleChecked();
     }
     split_map = Map::CopyWithField(map, MakeString("dbl"), any_type, NONE,
                                    Representation::Double(),
                                    INSERT_TRANSITION).ToHandleChecked();
   }
   Handle<LayoutDescriptor> split_layout_descriptor(
       split_map->layout_descriptor(), isolate);
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(split_layout_descriptor->IsConsistentWithMap(*split_map));
-  }
-#endif
+  CHECK(split_layout_descriptor->IsConsistentWithMap(*split_map));
   CHECK(split_layout_descriptor->IsSlowLayout());
   CHECK(split_map->owns_descriptors());
 
   Handle<Map> map1 = Map::CopyWithField(split_map, MakeString("foo"), any_type,
                                         NONE, Representation::Double(),
                                         INSERT_TRANSITION).ToHandleChecked();
   CHECK(!split_map->owns_descriptors());
   CHECK_EQ(*split_layout_descriptor, split_map->layout_descriptor());
 
   // Layout descriptors should be shared with |split_map|.
   CHECK(map1->owns_descriptors());
   CHECK_EQ(*split_layout_descriptor, map1->layout_descriptor());
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(map1->layout_descriptor()->IsConsistentWithMap(*map1));
-  }
-#endif
+  CHECK(map1->layout_descriptor()->IsConsistentWithMap(*map1));
 
   Handle<Map> map2 = Map::CopyWithField(split_map, MakeString("bar"), any_type,
                                         NONE, Representation::Tagged(),
                                         INSERT_TRANSITION).ToHandleChecked();
 
   // Layout descriptors should not be shared with |split_map|.
   CHECK(map2->owns_descriptors());
   CHECK_NE(*split_layout_descriptor, map2->layout_descriptor());
-#ifdef VERIFY_HEAP
-  if (FLAG_verify_heap) {
-    DCHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2));
-  }
-#endif
+  CHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2));
 }
 
 
 TEST(StoreBufferScanOnScavenge) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
 
   CompileRun(
@@ skipping 132 matching lines @@
   Handle<JSObject> clone(JSObject::cast(clone_obj));
   CHECK(heap->old_pointer_space()->Contains(clone->address()));
 
   CcTest::heap()->CollectGarbage(NEW_SPACE, "boom");
 
   // The value in cloned object should not be corrupted by GC.
   CHECK_EQ(boom_value, clone->RawFastDoublePropertyAt(index));
 }
 
 #endif