ARM, ARM64: Optimize array copy

src/hydrogen.cc

 // Copyright 2013 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/hydrogen.h"
 
 #include <algorithm>
 
 #include "src/v8.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 2678 matching lines @@
 
 void HGraphBuilder::BuildFillElementsWithValue(HValue* elements,
                                                ElementsKind elements_kind,
                                                HValue* from,
                                                HValue* to,
                                                HValue* value) {
   if (to == NULL) {
     to = AddLoadFixedArrayLength(elements);
   }
 
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
+  from = AddUncasted<HForceRepresentation>(from, Representation::Integer32());
+  to = AddUncasted<HForceRepresentation>(to, Representation::Integer32());
+  Add<HFillElements>(elements, from, to, value);
+#else
   // Special loop unfolding case
   STATIC_ASSERT(JSArray::kPreallocatedArrayElements <=
                 kElementLoopUnrollThreshold);
   int initial_capacity = -1;
   if (from->IsInteger32Constant() && to->IsInteger32Constant()) {
     int constant_from = from->GetInteger32Constant();
     int constant_to = to->GetInteger32Constant();
 
     if (constant_from == 0 && constant_to <= kElementLoopUnrollThreshold) {
       initial_capacity = constant_to;
@@ skipping 20 matching lines @@
 
     HValue* key = builder.BeginBody(to, from, Token::GT);
 
     HValue* adjusted_key = AddUncasted<HSub>(key, graph()->GetConstant1());
     adjusted_key->ClearFlag(HValue::kCanOverflow);
 
     Add<HStoreKeyed>(elements, adjusted_key, value, elements_kind);
 
     builder.EndBody();
   }
+#endif
 }
 
 
 void HGraphBuilder::BuildFillElementsWithHole(HValue* elements,
                                               ElementsKind elements_kind,
                                               HValue* from,
                                               HValue* to) {
   // Fast elements kinds need to be initialized in case statements below cause a
   // garbage collection.
   Factory* factory = isolate()->factory();
@@ skipping 47 matching lines @@
     if (!pre_fill_with_holes &&
         (capacity == NULL || !length->Equals(capacity))) {
       BuildFillElementsWithHole(to_elements, to_elements_kind,
                                 length, NULL);
     }
 
     if (capacity == NULL) {
       capacity = AddLoadFixedArrayLength(to_elements);
     }
 
-    LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
+    if (from_elements_kind == to_elements_kind) {
+      length =
+         AddUncasted<HForceRepresentation>(length, Representation::Integer32());
+      Add<HCopyElements>(from_elements, to_elements, length, to_elements_kind);
+    } else {
+#endif
+      LoopBuilder builder(this, context(), LoopBuilder::kPostDecrement);
 
-    HValue* key = builder.BeginBody(length, graph()->GetConstant0(),
-                                    Token::GT);
+      HValue* key = builder.BeginBody(length, graph()->GetConstant0(),
+                                      Token::GT);
 
-    key = AddUncasted<HSub>(key, graph()->GetConstant1());
-    key->ClearFlag(HValue::kCanOverflow);
+      key = AddUncasted<HSub>(key, graph()->GetConstant1());
+      key->ClearFlag(HValue::kCanOverflow);
 
-    HValue* element = Add<HLoadKeyed>(from_elements, key,
-                                      static_cast<HValue*>(NULL),
-                                      from_elements_kind,
-                                      ALLOW_RETURN_HOLE);
+      HValue* element = Add<HLoadKeyed>(from_elements, key,
+                                        static_cast<HValue*>(NULL),
+                                        from_elements_kind,
+                                        ALLOW_RETURN_HOLE);
 
-    ElementsKind kind = (IsHoleyElementsKind(from_elements_kind) &&
-                         IsFastSmiElementsKind(to_elements_kind))
-      ? FAST_HOLEY_ELEMENTS : to_elements_kind;
+      ElementsKind kind = (IsHoleyElementsKind(from_elements_kind) &&
+                          IsFastSmiElementsKind(to_elements_kind))
+        ? FAST_HOLEY_ELEMENTS : to_elements_kind;
 
-    if (IsHoleyElementsKind(from_elements_kind) &&
-        from_elements_kind != to_elements_kind) {
-      IfBuilder if_hole(this);
-      if_hole.If<HCompareHoleAndBranch>(element);
-      if_hole.Then();
-      HConstant* hole_constant = IsFastDoubleElementsKind(to_elements_kind)
-        ? Add<HConstant>(FixedDoubleArray::hole_nan_as_double())
-        : graph()->GetConstantHole();
-      Add<HStoreKeyed>(to_elements, key, hole_constant, kind);
-      if_hole.Else();
-      HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
-      store->SetFlag(HValue::kAllowUndefinedAsNaN);
-      if_hole.End();
-    } else {
-      HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
-      store->SetFlag(HValue::kAllowUndefinedAsNaN);
+      if (IsHoleyElementsKind(from_elements_kind) &&
+          from_elements_kind != to_elements_kind) {
+        IfBuilder if_hole(this);
+        if_hole.If<HCompareHoleAndBranch>(element);
+        if_hole.Then();
+        HConstant* hole_constant = IsFastDoubleElementsKind(to_elements_kind)
+          ? Add<HConstant>(FixedDoubleArray::hole_nan_as_double())
+          : graph()->GetConstantHole();
+        Add<HStoreKeyed>(to_elements, key, hole_constant, kind);
+        if_hole.Else();
+        HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
+        store->SetFlag(HValue::kAllowUndefinedAsNaN);
+        if_hole.End();
+      } else {
+        HStoreKeyed* store = Add<HStoreKeyed>(to_elements, key, element, kind);
+        store->SetFlag(HValue::kAllowUndefinedAsNaN);
+      }
+
+      builder.EndBody();
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
     }
-
-    builder.EndBody();
+#endif
   }
 
   Counters* counters = isolate()->counters();
   AddIncrementCounter(counters->inlined_copied_elements());
 }
 
 
 HValue* HGraphBuilder::BuildCloneShallowArrayCow(HValue* boilerplate,
                                                  HValue* allocation_site,
                                                  AllocationSiteMode mode,
@@ skipping 9492 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal