[runtime][ic] Constant field tracking support.

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/accessors.h"
 #include "src/compilation-cache.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/field-type.h"
 #include "src/global-handles.h"
 #include "src/ic/ic.h"
 #include "src/macro-assembler.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 
@@ skipping 51 matching lines @@
 }
 
 void WriteToField(JSObject* object, int descriptor, Object* value) {
   DescriptorArray* descriptors = object->map()->instance_descriptors();
   PropertyDetails details = descriptors->GetDetails(descriptor);
   object->WriteToField(descriptor, details, value);
 }
 
 const int kNumberOfBits = 32;
 
-
 enum TestPropertyKind {
-  PROP_CONSTANT,
+  PROP_ACCESSOR_INFO,
   PROP_SMI,
   PROP_DOUBLE,
   PROP_TAGGED,
   PROP_KIND_NUMBER
 };
 
 static Representation representations[PROP_KIND_NUMBER] = {
     Representation::None(), Representation::Smi(), Representation::Double(),
     Representation::Tagged()};
 
 
 static Handle<DescriptorArray> CreateDescriptorArray(Isolate* isolate,
                                                      TestPropertyKind* props,
                                                      int kPropsCount) {
   Factory* factory = isolate->factory();
 
-  Handle<String> func_name = factory->InternalizeUtf8String("func");
-  Handle<JSFunction> func = factory->NewFunction(func_name);
-
   Handle<DescriptorArray> descriptors =
       DescriptorArray::Allocate(isolate, 0, kPropsCount);
 
   int next_field_offset = 0;
   for (int i = 0; i < kPropsCount; i++) {
     EmbeddedVector<char, 64> buffer;
     SNPrintF(buffer, "prop%d", i);
     Handle<String> name = factory->InternalizeUtf8String(buffer.start());
 
     TestPropertyKind kind = props[i];
 
-    if (kind == PROP_CONSTANT) {
-      Descriptor d = Descriptor::DataConstant(name, func, NONE);
-      descriptors->Append(&d);
+    Descriptor d;
+    if (kind == PROP_ACCESSOR_INFO) {
+      Handle<AccessorInfo> info =
+          Accessors::MakeAccessor(isolate, name, nullptr, nullptr, NONE);
+      d = Descriptor::AccessorConstant(name, info, NONE);
 
     } else {
-      Descriptor d = Descriptor::DataField(name, next_field_offset, NONE,
-                                           representations[kind]);
-      next_field_offset += d.GetDetails().field_width_in_words();
-      descriptors->Append(&d);
+      d = Descriptor::DataField(name, next_field_offset, NONE,
+                                representations[kind]);
+    }
+    descriptors->Append(&d);
+    PropertyDetails details = d.GetDetails();
+    if (details.location() == kField) {
+      next_field_offset += details.field_width_in_words();
     }
   }
   return descriptors;
 }
 
 
 TEST(LayoutDescriptorBasicFast) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
@@ skipping 348 matching lines @@
 }
 
 
 TEST(LayoutDescriptorCreateNewFast) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<LayoutDescriptor> layout_descriptor;
   TestPropertyKind props[] = {
-      PROP_CONSTANT,
+      PROP_ACCESSOR_INFO,
       PROP_TAGGED,  // field #0
-      PROP_CONSTANT,
+      PROP_ACCESSOR_INFO,
       PROP_DOUBLE,  // field #1
-      PROP_CONSTANT,
+      PROP_ACCESSOR_INFO,
       PROP_TAGGED,  // field #2
-      PROP_CONSTANT,
+      PROP_ACCESSOR_INFO,
   };
   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);
@@ skipping 101 matching lines @@
     CHECK_EQ(layout_desc, LayoutDescriptor::cast(layout_desc));
   }
 }
 
 
 static Handle<LayoutDescriptor> TestLayoutDescriptorAppend(
     Isolate* isolate, int inobject_properties, TestPropertyKind* props,
     int kPropsCount) {
   Factory* factory = isolate->factory();
 
-  Handle<String> func_name = factory->InternalizeUtf8String("func");
-  Handle<JSFunction> func = factory->NewFunction(func_name);
+  //  Handle<String> func_name = factory->InternalizeUtf8String("func");
+  //  Handle<JSFunction> func = factory->NewFunction(func_name);

[Toon Verwaest, 2017/02/09 16:06:09]

delete

[Igor Sheludko, 2017/02/09 17:08:14]

Done.

 
   Handle<DescriptorArray> descriptors =
       DescriptorArray::Allocate(isolate, 0, kPropsCount);
 
   Handle<Map> map = Map::Create(isolate, inobject_properties);
   map->InitializeDescriptors(*descriptors,
                              LayoutDescriptor::FastPointerLayout());
 
   int next_field_offset = 0;
   for (int i = 0; i < kPropsCount; i++) {
     EmbeddedVector<char, 64> buffer;
     SNPrintF(buffer, "prop%d", i);
     Handle<String> name = factory->InternalizeUtf8String(buffer.start());
 
     Handle<LayoutDescriptor> layout_descriptor;
     TestPropertyKind kind = props[i];
-    if (kind == PROP_CONSTANT) {
-      Descriptor d = Descriptor::DataConstant(name, func, NONE);
-      layout_descriptor = LayoutDescriptor::ShareAppend(map, d.GetDetails());
-      descriptors->Append(&d);
+    Descriptor d;
+    if (kind == PROP_ACCESSOR_INFO) {
+      Handle<AccessorInfo> info =
+          Accessors::MakeAccessor(isolate, name, nullptr, nullptr, NONE);
+      d = Descriptor::AccessorConstant(name, info, NONE);
 
     } else {
-      Descriptor d = Descriptor::DataField(name, next_field_offset, NONE,
-                                           representations[kind]);
-      int field_width_in_words = d.GetDetails().field_width_in_words();
+      d = Descriptor::DataField(name, next_field_offset, NONE,
+                                representations[kind]);
+    }
+    PropertyDetails details = d.GetDetails();
+    layout_descriptor = LayoutDescriptor::ShareAppend(map, details);
+    descriptors->Append(&d);
+    if (details.location() == kField) {
+      int field_width_in_words = details.field_width_in_words();
       next_field_offset += field_width_in_words;
-      layout_descriptor = LayoutDescriptor::ShareAppend(map, d.GetDetails());
-      descriptors->Append(&d);
 
-      int field_index = d.GetDetails().field_index();
+      int field_index = details.field_index();
       bool is_inobject = field_index < map->GetInObjectProperties();
       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);
@@ skipping 290 matching lines @@
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
 
   const int kFieldCount = 128;
   const int kSplitFieldIndex = 32;
   const int kTrimmedLayoutDescriptorLength = 64;
 
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, kFieldCount);
   for (int i = 0; i < kSplitFieldIndex; i++) {
-    map = Map::CopyWithField(map, MakeName("prop", i), any_type, NONE,
-                             Representation::Smi(),
-                             INSERT_TRANSITION).ToHandleChecked();
+    map = Map::CopyWithField(map, MakeName("prop", i), any_type, NONE, kMutable,
+                             Representation::Smi(), INSERT_TRANSITION)
+              .ToHandleChecked();
   }
-  map = Map::CopyWithField(map, MakeName("dbl", kSplitFieldIndex), any_type,
-                           NONE, Representation::Double(),
-                           INSERT_TRANSITION).ToHandleChecked();
+  map =
+      Map::CopyWithField(map, MakeName("dbl", kSplitFieldIndex), any_type, NONE,
+                         kMutable, Representation::Double(), INSERT_TRANSITION)
+          .ToHandleChecked();
   CHECK(map->layout_descriptor()->IsConsistentWithMap(*map, true));
   CHECK(map->layout_descriptor()->IsSlowLayout());
   CHECK(map->owns_descriptors());
   CHECK_EQ(2, map->layout_descriptor()->length());
 
   {
     // Add transitions to double fields.
     v8::HandleScope scope(CcTest::isolate());
 
     Handle<Map> tmp_map = map;
     for (int i = kSplitFieldIndex + 1; i < kFieldCount; i++) {
       tmp_map = Map::CopyWithField(tmp_map, MakeName("dbl", i), any_type, NONE,
-                                   Representation::Double(),
-                                   INSERT_TRANSITION).ToHandleChecked();
+                                   kMutable, Representation::Double(),
+                                   INSERT_TRANSITION)
+                    .ToHandleChecked();
       CHECK(tmp_map->layout_descriptor()->IsConsistentWithMap(*tmp_map, true));
     }
     // Check that descriptors are shared.
     CHECK(tmp_map->owns_descriptors());
     CHECK_EQ(map->instance_descriptors(), tmp_map->instance_descriptors());
     CHECK_EQ(map->layout_descriptor(), tmp_map->layout_descriptor());
   }
   CHECK(map->layout_descriptor()->IsSlowLayout());
   CHECK_EQ(4, map->layout_descriptor()->length());
 
@@ skipping 17 matching lines @@
   CHECK(map->layout_descriptor()->IsSlowLayout());
   CHECK_EQ(2, map->layout_descriptor()->length());
 
   {
     // Add transitions to tagged fields.
     v8::HandleScope scope(CcTest::isolate());
 
     Handle<Map> tmp_map = map;
     for (int i = kSplitFieldIndex + 1; i < kFieldCount - 1; i++) {
       tmp_map = Map::CopyWithField(tmp_map, MakeName("tagged", i), any_type,
-                                   NONE, Representation::Tagged(),
-                                   INSERT_TRANSITION).ToHandleChecked();
+                                   NONE, kMutable, Representation::Tagged(),
+                                   INSERT_TRANSITION)
+                    .ToHandleChecked();
       CHECK(tmp_map->layout_descriptor()->IsConsistentWithMap(*tmp_map, true));
     }
-    tmp_map = Map::CopyWithField(tmp_map, MakeString("dbl"), any_type, NONE,
-                                 Representation::Double(),
-                                 INSERT_TRANSITION).ToHandleChecked();
+    tmp_map =
+        Map::CopyWithField(tmp_map, MakeString("dbl"), any_type, NONE, kMutable,
+                           Representation::Double(), INSERT_TRANSITION)
+            .ToHandleChecked();
     CHECK(tmp_map->layout_descriptor()->IsConsistentWithMap(*tmp_map, true));
     // Check that descriptors are shared.
     CHECK(tmp_map->owns_descriptors());
     CHECK_EQ(map->instance_descriptors(), tmp_map->instance_descriptors());
   }
   CHECK(map->layout_descriptor()->IsSlowLayout());
 }
 
 
 TEST(DoScavenge) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
   // The plan: create |obj| with double field in new space, do scanvenge so
   // that |obj| is moved to old space, construct a double value that looks like
   // 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<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
-  map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
-                           Representation::Double(),
-                           INSERT_TRANSITION).ToHandleChecked();
+  map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE, kMutable,
+                           Representation::Double(), INSERT_TRANSITION)
+            .ToHandleChecked();
 
   // Create object in new space.
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map, NOT_TENURED);
 
   Handle<HeapNumber> heap_number = factory->NewHeapNumber(42.5);
   WriteToField(*obj, 0, *heap_number);
 
   {
     // Ensure the object is properly set up.
     FieldIndex field_index = FieldIndex::ForDescriptor(*map, 0);
@@ skipping 39 matching lines @@
   PagedSpace* old_space = heap->old_space();
 
   // The plan: create |obj_value| in old space and ensure that it is allocated
   // on evacuation candidate page, create |obj| with double and tagged fields
   // in new space and write |obj_value| to tagged field of |obj|, do two
   // scavenges to promote |obj| to old space, a GC in old space and ensure that
   // the tagged value was properly updated after candidates evacuation.
 
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<Map> map = Map::Create(isolate, 10);
-  map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE,
-                           Representation::Double(),
-                           INSERT_TRANSITION).ToHandleChecked();
-  map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE,
-                           Representation::Tagged(),
-                           INSERT_TRANSITION).ToHandleChecked();
+  map = Map::CopyWithField(map, MakeName("prop", 0), any_type, NONE, kMutable,
+                           Representation::Double(), INSERT_TRANSITION)
+            .ToHandleChecked();
+  map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE, kMutable,
+                           Representation::Tagged(), INSERT_TRANSITION)
+            .ToHandleChecked();
 
   // Create |obj_value| in old space.
   Handle<HeapObject> obj_value;
   Page* ec_page;
   {
     AlwaysAllocateScope always_allocate(isolate);
     // Make sure |obj_value| is placed on an old-space evacuation candidate.
     heap::SimulateFullSpace(old_space);
     obj_value = factory->NewJSArray(32 * KB, FAST_HOLEY_ELEMENTS, TENURED);
     ec_page = Page::FromAddress(obj_value->address());
@@ skipping 202 matching lines @@
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<Map> split_map;
   {
     Handle<Map> map = Map::Create(isolate, 64);
     for (int i = 0; i < 32; i++) {
       Handle<String> name = MakeName("prop", i);
-      map = Map::CopyWithField(map, name, any_type, NONE, Representation::Smi(),
-                               INSERT_TRANSITION).ToHandleChecked();
+      map = Map::CopyWithField(map, name, any_type, NONE, kMutable,
+                               Representation::Smi(), INSERT_TRANSITION)
+                .ToHandleChecked();
     }
-    split_map = Map::CopyWithField(map, MakeString("dbl"), any_type, NONE,
-                                   Representation::Double(),
-                                   INSERT_TRANSITION).ToHandleChecked();
+    split_map =
+        Map::CopyWithField(map, MakeString("dbl"), any_type, NONE, kMutable,
+                           Representation::Double(), INSERT_TRANSITION)
+            .ToHandleChecked();
   }
   Handle<LayoutDescriptor> split_layout_descriptor(
       split_map->layout_descriptor(), isolate);
   CHECK(split_layout_descriptor->IsConsistentWithMap(*split_map, true));
   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();
+  Handle<Map> map1 =
+      Map::CopyWithField(split_map, MakeString("foo"), any_type, NONE, kMutable,
+                         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());
   CHECK(map1->layout_descriptor()->IsConsistentWithMap(*map1, true));
 
-  Handle<Map> map2 = Map::CopyWithField(split_map, MakeString("bar"), any_type,
-                                        NONE, Representation::Tagged(),
-                                        INSERT_TRANSITION).ToHandleChecked();
+  Handle<Map> map2 =
+      Map::CopyWithField(split_map, MakeString("bar"), any_type, NONE, kMutable,
+                         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());
   CHECK(map2->layout_descriptor()->IsConsistentWithMap(*map2, true));
 }
 
 
 static void TestWriteBarrier(Handle<Map> map, Handle<Map> new_map,
                              int tagged_descriptor, int double_descriptor,
@@ skipping 149 matching lines @@
 
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   CompileRun("function func() { return 1; }");
 
   Handle<JSObject> func = GetObject("func");
 
   Handle<Map> map = Map::Create(isolate, 10);
   map = Map::CopyWithConstant(map, MakeName("prop", 0), func, NONE,
                               INSERT_TRANSITION).ToHandleChecked();
-  map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE,
-                           Representation::Double(),
-                           INSERT_TRANSITION).ToHandleChecked();
-  map = Map::CopyWithField(map, MakeName("prop", 2), any_type, NONE,
-                           Representation::Tagged(),
-                           INSERT_TRANSITION).ToHandleChecked();
+  map = Map::CopyWithField(map, MakeName("prop", 1), any_type, NONE, kMutable,
+                           Representation::Double(), INSERT_TRANSITION)
+            .ToHandleChecked();
+  map = Map::CopyWithField(map, MakeName("prop", 2), any_type, NONE, kMutable,
+                           Representation::Tagged(), INSERT_TRANSITION)
+            .ToHandleChecked();
 
   // Shift fields right by turning constant property to a field.
   Handle<Map> new_map = Map::ReconfigureProperty(
       map, 0, kData, NONE, Representation::Tagged(), any_type);
 
   if (write_barrier_kind == OLD_TO_NEW_WRITE_BARRIER) {
     TestWriteBarrier(map, new_map, 2, 1);
   } else {
     CHECK_EQ(OLD_TO_OLD_WRITE_BARRIER, write_barrier_kind);
     TestIncrementalWriteBarrier(map, new_map, 2, 1);
@@ skipping 12 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