LayoutDescriptor should inherit from JSTypedArray

src/layout-descriptor.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 <sstream>
 
 #include "src/v8.h"
 
 #include "src/base/bits.h"
 #include "src/layout-descriptor.h"
@@ skipping 88 matching lines @@
     int new_capacity) {
   int old_capacity = layout_descriptor->capacity();
   if (new_capacity <= old_capacity) {
     return layout_descriptor;
   }
   Handle<LayoutDescriptor> new_layout_descriptor =
       LayoutDescriptor::New(isolate, new_capacity);
   DCHECK(new_layout_descriptor->IsSlowLayout());
 
   if (layout_descriptor->IsSlowLayout()) {
-    memcpy(new_layout_descriptor->DataPtr(), layout_descriptor->DataPtr(),
-           layout_descriptor->DataSize());
+    DisallowHeapAllocation no_gc;
+    Handle<FixedTypedArrayBase> elements(
+        FixedTypedArrayBase::cast(layout_descriptor->elements()));
+    Handle<FixedTypedArrayBase> new_elements(
+        FixedTypedArrayBase::cast(new_layout_descriptor->elements()));
+    memcpy(new_elements->DataPtr(), elements->DataPtr(), elements->DataSize());
     return new_layout_descriptor;
   } else {
     // Fast layout.
     uint32_t value =
         static_cast<uint32_t>(Smi::cast(*layout_descriptor)->value());
     new_layout_descriptor->set(0, value);
     return new_layout_descriptor;
   }
 }
 
@@ skipping 22 matching lines @@
 
   bool is_tagged = (value & layout_mask) == 0;
   if (!is_tagged) value = ~value;  // Count set bits instead of cleared bits.
   value = value & ~(layout_mask - 1);  // Clear bits we are not interested in.
   int sequence_length = CountTrailingZeros32(value) - layout_bit_index;
 
   if (layout_bit_index + sequence_length == kNumberOfBits) {
     // This is a contiguous sequence till the end of current word, proceed
     // counting in the subsequent words.
     if (IsSlowLayout()) {
-      int len = length();
+      int len = Smi::cast(length())->value();
       ++layout_word_index;
       for (; layout_word_index < len; layout_word_index++) {
         value = get_scalar(layout_word_index);
         bool cur_is_tagged = (value & 1) == 0;
         if (cur_is_tagged != is_tagged) break;
         if (!is_tagged) value = ~value;  // Count set bits instead.
         int cur_sequence_length = CountTrailingZeros32(value);
         sequence_length += cur_sequence_length;
         if (sequence_length >= max_sequence_length) break;
         if (cur_sequence_length != kNumberOfBits) break;
@@ skipping 70 matching lines @@
   if (!IsSlowLayout()) return this;
 
   int layout_descriptor_length =
       CalculateCapacity(map, descriptors, num_descriptors);
   // It must not become fast-mode descriptor here, because otherwise it has to
   // be fast pointer layout descriptor already but it's is slow mode now.
   DCHECK_LT(kSmiValueSize, layout_descriptor_length);
 
   // Trim, clean and reinitialize this slow-mode layout descriptor.
   int array_length = GetSlowModeBackingStoreLength(layout_descriptor_length);
-  int current_length = length();
+  int current_length = Smi::cast(length())->value();
   if (current_length != array_length) {
     DCHECK_LT(array_length, current_length);
     int delta = current_length - array_length;
-    heap->RightTrimFixedArray<Heap::SEQUENTIAL_TO_SWEEPER>(this, delta);
+    heap->RightTrimFixedArray<Heap::SEQUENTIAL_TO_SWEEPER>(elements(), delta);
+    set_byte_length(Smi::FromInt(array_length * 4));
+    set_length(Smi::FromInt(array_length));
   }
-  memset(DataPtr(), 0, DataSize());
+  {
+    DisallowHeapAllocation no_gc;
+    Handle<FixedTypedArrayBase> fixed_array(
+        FixedTypedArrayBase::cast(elements()));
+    memset(fixed_array->DataPtr(), 0, fixed_array->DataSize());
+  }
   LayoutDescriptor* layout_descriptor =
       Initialize(this, map, descriptors, num_descriptors);
   DCHECK_EQ(this, layout_descriptor);
   return layout_descriptor;
 }
 
 
 bool LayoutDescriptor::IsConsistentWithMap(Map* map, bool check_tail) {
   if (FLAG_unbox_double_fields) {
     DescriptorArray* descriptors = map->instance_descriptors();
@@ skipping 18 matching lines @@
       int n = capacity();
       for (int i = last_field_index; i < n; i++) {
         DCHECK(IsTagged(i));
       }
     }
   }
   return true;
 }
 }
 }  // namespace v8::internal