Remove unused byte from Map::instance_sizes field.

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 999 matching lines @@
   // a pointer to "from space" pointer. Do scavenge one more time and ensure
   // that it didn't crash or corrupt the double value stored in the object.
 
   Handle<HeapType> any_type = HeapType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create object in new space.
-  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED, false);
+  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
 
   {
     // Ensure the object is properly set up.
     FieldIndex field_index = FieldIndex::ForDescriptor(*map, 0);
     CHECK(field_index.is_inobject() && field_index.is_double());
     CHECK_EQ(FLAG_unbox_double_fields, map->IsUnboxedDoubleField(field_index));
     CHECK_EQ(42.5, GetDoubleFieldValue(*obj, field_index));
@@ skipping 56 matching lines @@
   {
     AlwaysAllocateScope always_allocate(isolate);
     // Make sure |obj_value| is placed on an old-space evacuation candidate.
     SimulateFullSpace(old_space);
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS,
                                     Strength::WEAK, TENURED);
     ec_page = Page::FromAddress(obj_value->address());
   }
 
   // Create object in new space.
-  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED, false);
+  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
   obj->WriteToField(1, *obj_value);
 
   {
     // Ensure the object is properly set up.
     FieldIndex field_index = FieldIndex::ForDescriptor(*map, 0);
     CHECK(field_index.is_inobject() && field_index.is_double());
     CHECK_EQ(FLAG_unbox_double_fields, map->IsUnboxedDoubleField(field_index));
@@ skipping 236 matching lines @@
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<HeapType> any_type = HeapType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
                            Representation::Double(),
                            INSERT_TRANSITION).ToHandleChecked();
 
   // Create object in new space.
-  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED, false);
+  Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   obj->WriteToField(0, *heap_number);
 
   {
     // Ensure the object is properly set up.
     DescriptorArray* descriptors = map->instance_descriptors();
     CHECK(descriptors->GetDetails(0).representation().IsDouble());
     FieldIndex field_index = FieldIndex::ForDescriptor(*map, 0);
     CHECK(field_index.is_inobject() && field_index.is_double());
@@ skipping 51 matching lines @@
   // that the value of the unboxed double property of the cloned object has
   // was not corrupted by GC.
 
   // Step 1: prepare a map for the object. We add unboxed double property to it.
   // Create a map with single inobject property.
   Handle<Map> my_map = Map::Create(isolate, 1);
   Handle<String> name = isolate->factory()->InternalizeUtf8String("foo");
   my_map = Map::CopyWithField(my_map, name, HeapType::Any(isolate), NONE,
                               Representation::Double(),
                               INSERT_TRANSITION).ToHandleChecked();
-  my_map->set_pre_allocated_property_fields(1);
-  int n_properties = my_map->InitialPropertiesLength();
-  CHECK_GE(n_properties, 0);
 
   int object_size = my_map->instance_size();
 
   // Step 2: allocate a lot of objects so to almost fill new space: we need
   // just enough room to allocate JSObject and thus fill the newspace.
 
   int allocation_amount =
       Min(FixedArray::kMaxSize, Page::kMaxRegularHeapObjectSize + kPointerSize);
   int allocation_len = LenFromSize(allocation_amount);
   NewSpace* new_space = heap->new_space();
@@ skipping 57 matching lines @@
   // new space and ensure that write barrier is triggered when |obj_value| is
   // written to property |tagged_descriptor| of |obj|.
   // Then migrate object to |new_map| and set proper value for property
   // |double_descriptor|. Call GC and ensure that it did not crash during
   // store buffer entries updating.
 
   Handle<JSObject> obj;
   Handle<HeapObject> obj_value;
   {
     AlwaysAllocateScope always_allocate(isolate);
-    obj = factory->NewJSObjectFromMap(map, TENURED, false);
+    obj = factory->NewJSObjectFromMap(map, TENURED);
     CHECK(old_space->Contains(*obj));
 
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS);
   }
 
   CHECK(heap->InNewSpace(*obj_value));
 
   {
     FieldIndex index = FieldIndex::ForDescriptor(*map, tagged_descriptor);
     const int n = 153;
@@ skipping 44 matching lines @@
   // when |obj_value| is written to property |tagged_descriptor| of |obj|.
   // Then migrate object to |new_map| and set proper value for property
   // |double_descriptor|. Call GC and ensure that it did not crash during
   // slots buffer entries updating.
 
   Handle<JSObject> obj;
   Handle<HeapObject> obj_value;
   Page* ec_page;
   {
     AlwaysAllocateScope always_allocate(isolate);
-    obj = factory->NewJSObjectFromMap(map, TENURED, false);
+    obj = factory->NewJSObjectFromMap(map, TENURED);
     CHECK(old_space->Contains(*obj));
 
     // Make sure |obj_value| is placed on an old-space evacuation candidate.
     SimulateFullSpace(old_space);
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS,
                                     Strength::WEAK, TENURED);
     ec_page = Page::FromAddress(obj_value->address());
     CHECK_NE(ec_page, Page::FromAddress(obj->address()));
   }
 
@@ skipping 101 matching lines @@
 
 // TODO(ishell): add respective tests for property kind reconfiguring from
 // accessor field to double, once accessor fields are supported by
 // Map::ReconfigureProperty().
 
 
 // TODO(ishell): add respective tests for fast property removal case once
 // Map::ReconfigureProperty() supports that.
 
 #endif