Remove LeftTrimFixedArray

src/elements.cc

 // Copyright 2012 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 "src/elements.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/messages.h"
@@ skipping 1319 matching lines @@
   static Handle<Object> ShiftImpl(Handle<JSArray> receiver,
                                   Handle<FixedArrayBase> backing_store) {
     uint32_t len =
         static_cast<uint32_t>(Smi::cast(receiver->length())->value());
     Isolate* isolate = receiver->GetIsolate();
     DCHECK(len > 0);
     int new_length = len - 1;
     Handle<Object> result =
         FastElementsAccessorSubclass::GetImpl(backing_store, 0);
     Heap* heap = isolate->heap();
-    if (heap->CanMoveObjectStart(*backing_store)) {
-      receiver->set_elements(heap->LeftTrimFixedArray(*backing_store, 1));
-    } else {
-      FastElementsAccessorSubclass::MoveElements(heap, backing_store, 0, 1,
-                                                 new_length, 0, 0);
-    }
+    FastElementsAccessorSubclass::MoveElements(heap, backing_store, 0, 1,
+                                               new_length, 0, 0);
     FastElementsAccessorSubclass::SetLengthImpl(receiver, new_length,
                                                 backing_store);
 
     if (IsHoleyElementsKind(KindTraits::Kind) && result->IsTheHole()) {
       result = receiver->GetIsolate()->factory()->undefined_value();
     }
     return result;
   }
 
   static uint32_t PushImpl(Handle<JSArray> receiver,
@@ skipping 146 matching lines @@
     return deleted_elements;
   }
 
  private:
   static bool SpliceShrinkStep(Handle<FixedArrayBase>& backing_store,
                                Heap* heap, uint32_t start,
                                uint32_t delete_count, uint32_t add_count,
                                uint32_t len, uint32_t new_length) {
     const int move_left_count = len - delete_count - start;
     const int move_left_dst_index = start + add_count;
-    const bool left_trim_array = heap->CanMoveObjectStart(*backing_store) &&
-                                 (move_left_dst_index < move_left_count);
-    if (left_trim_array) {
-      const int delta = delete_count - add_count;
-      // shift from before the insertion point to the right
-      FastElementsAccessorSubclass::MoveElements(heap, backing_store, delta, 0,
-                                                 start, 0, 0);
-      backing_store = handle(heap->LeftTrimFixedArray(*backing_store, delta));
-      return true;
-    } else {
-      // No left-trim needed or possible (in this case we left-move and store
-      // the hole)
-      FastElementsAccessorSubclass::MoveElements(
-          heap, backing_store, move_left_dst_index, start + delete_count,
-          move_left_count, new_length, len);
-    }
+    FastElementsAccessorSubclass::MoveElements(
+        heap, backing_store, move_left_dst_index, start + delete_count,
+        move_left_count, new_length, len);
     return false;
   }
 
 
   static bool SpliceGrowStep(Handle<JSArray> receiver,
                              Handle<FixedArrayBase>& backing_store,
                              Isolate* isolate, Heap* heap, uint32_t start,
                              uint32_t delete_count, uint32_t add_count,
                              uint32_t len, uint32_t new_length) {
     // Currently fixed arrays cannot grow too big, so
@@ skipping 871 matching lines @@
     }
   }
 
   DCHECK(j == result_len);
   return result_array;
 }
 
 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL;
 }  // namespace internal
 }  // namespace v8