Fix compilation for the case dcheck_always_on=1.

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"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/ic/ic.h"
 #include "src/macro-assembler.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::base;
 using namespace v8::internal;
 
 #if (V8_DOUBLE_FIELDS_UNBOXING)
 
 
 //
 // 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
+}
+
+
 static Handle<String> MakeString(const char* str) {
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   return factory->InternalizeUtf8String(str);
 }
 
 
 static Handle<String> MakeName(const char* str, int suffix) {
   EmbeddedVector<char, 128> buffer;
   SNPrintF(buffer, "%s%d", str, suffix);
@@ skipping 111 matching lines @@
 
   {
     Handle<DescriptorArray> descriptors =
         CreateDescriptorArray(isolate, props, kPropsCount);
 
     Handle<Map> map = Map::Create(isolate, kPropsCount);
 
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_EQ(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK_EQ(kSmiValueSize, layout_descriptor->capacity());
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   props[0] = PROP_DOUBLE;
   props[kPropsCount - 1] = PROP_DOUBLE;
 
   Handle<DescriptorArray> descriptors =
       CreateDescriptorArray(isolate, props, kPropsCount);
 
   {
     int inobject_properties = kPropsCount - 1;
     Handle<Map> map = Map::Create(isolate, inobject_properties);
 
     // Should be fast as the only double property is the first one.
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(!layout_descriptor->IsSlowLayout());
     CHECK(!layout_descriptor->IsFastPointerLayout());
 
     CHECK_EQ(false, layout_descriptor->IsTagged(0));
     for (int i = 1; i < kPropsCount; i++) {
       CHECK_EQ(true, layout_descriptor->IsTagged(i));
     }
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     int inobject_properties = kPropsCount;
     Handle<Map> map = Map::Create(isolate, inobject_properties);
 
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(layout_descriptor->IsSlowLayout());
     CHECK(!layout_descriptor->IsFastPointerLayout());
     CHECK(layout_descriptor->capacity() > kSmiValueSize);
 
     CHECK_EQ(false, layout_descriptor->IsTagged(0));
     CHECK_EQ(false, layout_descriptor->IsTagged(kPropsCount - 1));
     for (int i = 1; i < kPropsCount - 1; i++) {
       CHECK_EQ(true, layout_descriptor->IsTagged(i));
     }
 
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
 
     // Here we have truly slow layout descriptor, so play with the bits.
     CHECK_EQ(true, layout_descriptor->IsTagged(-1));
     CHECK_EQ(true, layout_descriptor->IsTagged(-12347));
     CHECK_EQ(true, layout_descriptor->IsTagged(15635));
 
     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());
-
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+#ifdef VERIFY_HEAP
+    if (FLAG_verify_heap) {
+      DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    }
+#endif
   }
 }
 
 
 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 241 matching lines @@
   };
   const int kPropsCount = arraysize(props);
 
   Handle<DescriptorArray> descriptors =
       CreateDescriptorArray(isolate, props, kPropsCount);
 
   {
     Handle<Map> map = Map::Create(isolate, 0);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_EQ(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     Handle<Map> map = Map::Create(isolate, 1);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_EQ(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     Handle<Map> map = Map::Create(isolate, 2);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(!layout_descriptor->IsSlowLayout());
     CHECK_EQ(true, layout_descriptor->IsTagged(0));
     CHECK_EQ(false, layout_descriptor->IsTagged(1));
     CHECK_EQ(true, layout_descriptor->IsTagged(2));
     CHECK_EQ(true, layout_descriptor->IsTagged(125));
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 }
 
 
 TEST(LayoutDescriptorCreateNewSlow) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<LayoutDescriptor> layout_descriptor;
   const int kPropsCount = kSmiValueSize * 3;
   TestPropertyKind props[kPropsCount];
   for (int i = 0; i < kPropsCount; i++) {
     props[i] = static_cast<TestPropertyKind>(i % PROP_KIND_NUMBER);
   }
 
   Handle<DescriptorArray> descriptors =
       CreateDescriptorArray(isolate, props, kPropsCount);
 
   {
     Handle<Map> map = Map::Create(isolate, 0);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_EQ(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     Handle<Map> map = Map::Create(isolate, 1);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_EQ(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     Handle<Map> map = Map::Create(isolate, 2);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(!layout_descriptor->IsSlowLayout());
     CHECK_EQ(true, layout_descriptor->IsTagged(0));
     CHECK_EQ(false, layout_descriptor->IsTagged(1));
     CHECK_EQ(true, layout_descriptor->IsTagged(2));
     CHECK_EQ(true, layout_descriptor->IsTagged(125));
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
   }
 
   {
     int inobject_properties = kPropsCount / 2;
     Handle<Map> map = Map::Create(isolate, inobject_properties);
     layout_descriptor = LayoutDescriptor::New(map, descriptors, kPropsCount);
     CHECK_NE(LayoutDescriptor::FastPointerLayout(), *layout_descriptor);
     CHECK(layout_descriptor->IsSlowLayout());
     for (int i = 0; i < inobject_properties; i++) {
       // PROP_DOUBLE has index 1 among DATA properties.
       const bool tagged = (i % (PROP_KIND_NUMBER - 1)) != 1;
       CHECK_EQ(tagged, layout_descriptor->IsTagged(i));
     }
     // Every property after inobject_properties must be tagged.
     for (int i = inobject_properties; i < kPropsCount; i++) {
       CHECK_EQ(true, layout_descriptor->IsTagged(i));
     }
-    map->InitializeDescriptors(*descriptors, *layout_descriptor);
-    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+    InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
 
     // Now test LayoutDescriptor::cast_gc_safe().
     Handle<LayoutDescriptor> layout_descriptor_copy =
         LayoutDescriptor::New(map, descriptors, kPropsCount);
 
     LayoutDescriptor* layout_desc = *layout_descriptor;
     CHECK_EQ(layout_desc, LayoutDescriptor::cast(layout_desc));
     CHECK_EQ(layout_desc, LayoutDescriptor::cast_gc_safe(layout_desc));
     CHECK(layout_descriptor->IsFixedTypedArrayBase());
     // Now make it look like a forwarding pointer to layout_descriptor_copy.
@@ skipping 51 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);
-  DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+  }
+#endif
   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));
       }
     }
-    DCHECK(map->layout_descriptor()->IsConsistentWithMap(*map));
+#ifdef VERIFY_HEAP
+    if (FLAG_verify_heap) {
+      DCHECK(map->layout_descriptor()->IsConsistentWithMap(*map));
+    }
+#endif
   }
 
   Handle<LayoutDescriptor> layout_descriptor(map->GetLayoutDescriptor(),
                                              isolate);
-  DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+  }
+#endif
   return layout_descriptor;
 }
 
 
 TEST(LayoutDescriptorAppendIfFastOrUseFull) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<LayoutDescriptor> layout_descriptor;
@@ skipping 184 matching lines @@
 
 
 static void TestLayoutDescriptorHelper(Isolate* isolate,
                                        int inobject_properties,
                                        Handle<DescriptorArray> descriptors,
                                        int number_of_descriptors) {
   Handle<Map> map = Map::Create(isolate, inobject_properties);
 
   Handle<LayoutDescriptor> layout_descriptor = LayoutDescriptor::New(
       map, descriptors, descriptors->number_of_descriptors());
-  map->InitializeDescriptors(*descriptors, *layout_descriptor);
-  DCHECK(layout_descriptor->IsConsistentWithMap(*map));
+  InitializeVerifiedMapDescriptors(*map, *descriptors, *layout_descriptor);
 
   LayoutDescriptorHelper helper(*map);
   bool all_fields_tagged = true;
 
   int instance_size = map->instance_size();
 
   int end_offset = instance_size * 2;
   int first_non_tagged_field_offset = end_offset;
   for (int i = 0; i < number_of_descriptors; i++) {
     PropertyDetails details = descriptors->GetDetails(i);
@@ skipping 135 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);
-  DCHECK(split_layout_descriptor->IsConsistentWithMap(*split_map));
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    DCHECK(split_layout_descriptor->IsConsistentWithMap(*split_map));
+  }
+#endif
   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());
-  DCHECK(map1->layout_descriptor()->IsConsistentWithMap(*map1));
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    DCHECK(map1->layout_descriptor()->IsConsistentWithMap(*map1));
+  }
+#endif
 
   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());
-  DCHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2));
+#ifdef VERIFY_HEAP
+  if (FLAG_verify_heap) {
+    DCHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2));
+  }
+#endif
 }
 
 
 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