Revert of Reland "LayoutDescriptor should inherit from JSTypedArray"

src/layout-descriptor-inl.h

 // 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.
 
 #ifndef V8_LAYOUT_DESCRIPTOR_INL_H_
 #define V8_LAYOUT_DESCRIPTOR_INL_H_
 
 #include "src/layout-descriptor.h"
 
 namespace v8 {
 namespace internal {
 
 LayoutDescriptor* LayoutDescriptor::FromSmi(Smi* smi) {
   return LayoutDescriptor::cast(smi);
 }
 
 
 Handle<LayoutDescriptor> LayoutDescriptor::New(Isolate* isolate, int length) {
   if (length <= kSmiValueSize) {
     // The whole bit vector fits into a smi.
     return handle(LayoutDescriptor::FromSmi(Smi::FromInt(0)), isolate);
   }
   length = GetSlowModeBackingStoreLength(length);
   return Handle<LayoutDescriptor>::cast(
-      isolate->factory()->NewJSTypedArray(UINT32_ELEMENTS, length));
+      isolate->factory()->NewFixedTypedArray(length, kExternalUint32Array));
 }
 
 
 bool LayoutDescriptor::InobjectUnboxedField(int inobject_properties,
                                             PropertyDetails details) {
   if (details.type() != DATA || !details.representation().IsDouble()) {
     return false;
   }
   // We care only about in-object properties.
   return details.field_index() < inobject_properties;
 }
 
 
 LayoutDescriptor* LayoutDescriptor::FastPointerLayout() {
   return LayoutDescriptor::FromSmi(Smi::FromInt(0));
 }
 
 
 bool LayoutDescriptor::GetIndexes(int field_index, int* layout_word_index,
                                   int* layout_bit_index) {
   if (static_cast<unsigned>(field_index) >= static_cast<unsigned>(capacity())) {
     return false;
   }
 
   *layout_word_index = field_index / kNumberOfBits;
-  CHECK((!IsSmi() && (*layout_word_index < Smi::cast(length())->value())) ||
+  CHECK((!IsSmi() && (*layout_word_index < length())) ||
         (IsSmi() && (*layout_word_index < 1)));
 
   *layout_bit_index = field_index % kNumberOfBits;
   return true;
 }
 
 
 LayoutDescriptor* LayoutDescriptor::SetTagged(int field_index, bool tagged) {
   int layout_word_index;
   int layout_bit_index;
@@ skipping 54 matching lines @@
 
 bool LayoutDescriptor::IsFastPointerLayout(Object* layout_descriptor) {
   return layout_descriptor == FastPointerLayout();
 }
 
 
 bool LayoutDescriptor::IsSlowLayout() { return !IsSmi(); }
 
 
 int LayoutDescriptor::capacity() {
-  return IsSlowLayout() ? (Smi::cast(length())->value() * kNumberOfBits)
-                        : kSmiValueSize;
+  return IsSlowLayout() ? (length() * kNumberOfBits) : kSmiValueSize;
 }
 
 
-uint32_t LayoutDescriptor::get_scalar(int index) {
-  DCHECK(IsSlowLayout());
-  return GcSafeElements()->get_scalar(index);
-}
-
-
-void LayoutDescriptor::set(int index, uint32_t value) {
-  DCHECK(IsSlowLayout());
-  GcSafeElements()->set(index, value);
-}
-
-
 LayoutDescriptor* LayoutDescriptor::cast_gc_safe(Object* object) {
   if (object->IsSmi()) {
     // Fast mode layout descriptor.
     return reinterpret_cast<LayoutDescriptor*>(object);
   }
 
   // This is a mixed descriptor which is a fixed typed array.
   MapWord map_word = reinterpret_cast<HeapObject*>(object)->map_word();
   if (map_word.IsForwardingAddress()) {
     // Mark-compact has already moved layout descriptor.
@@ skipping 67 matching lines @@
     int field_index = details.field_index();
     layout_descriptor = layout_descriptor->SetRawData(field_index);
     if (details.field_width_in_words() > 1) {
       layout_descriptor = layout_descriptor->SetRawData(field_index + 1);
     }
   }
   return layout_descriptor;
 }
 
 
-FixedTypedArray<Uint32ArrayTraits>* LayoutDescriptor::GcSafeElements() {
-  MapWord map_word = HeapObject::cast(elements())->map_word();
-  if (map_word.IsForwardingAddress()) {
-    return FixedTypedArray<Uint32ArrayTraits>::cast(
-        map_word.ToForwardingAddress());
-  }
-  return FixedTypedArray<Uint32ArrayTraits>::cast(elements());
-}
-
-
 // InobjectPropertiesHelper is a helper class for querying whether inobject
 // property at offset is Double or not.
 LayoutDescriptorHelper::LayoutDescriptorHelper(Map* map)
     : all_fields_tagged_(true),
       header_size_(0),
       layout_descriptor_(LayoutDescriptor::FastPointerLayout()) {
   if (!FLAG_unbox_double_fields) return;
 
   layout_descriptor_ = map->layout_descriptor_gc_safe();
   if (layout_descriptor_->IsFastPointerLayout()) {
@@ skipping 15 matching lines @@
   // Object headers do not contain non-tagged fields.
   if (offset_in_bytes < header_size_) return true;
   int field_index = (offset_in_bytes - header_size_) / kPointerSize;
 
   return layout_descriptor_->IsTagged(field_index);
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_LAYOUT_DESCRIPTOR_INL_H_