ARM, ARM64: Optimize array copy

src/arm64/lithium-codegen-arm64.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/v8.h"
 
 #include "src/arm64/lithium-codegen-arm64.h"
 #include "src/arm64/lithium-gap-resolver-arm64.h"
 #include "src/code-stubs.h"
 #include "src/stub-cache.h"
@@ skipping 5146 matching lines @@
     DeoptimizeIfRoot(
         payload, Heap::kTheHoleValueRootIndex, instr->environment());
   }
 
   // Store the value.
   __ Str(value, FieldMemOperand(cell, Cell::kValueOffset));
   // Cells are always rescanned, so no write barrier here.
 }
 
 
+void LCodeGen::DoFillElements(LFillElements* instr) {
+  Register elements = ToRegister(instr->elements());
+  UseScratchRegisterScope temps(masm());
+  Register dst = temps.AcquireX();
+  CPURegister value;
+  if (instr->value()->IsDoubleRegister()) {
+    value = ToDoubleRegister(instr->value());
+  } else {
+    value = ToRegister(instr->value());
+  }
+  Register remain;
+  if (instr->from()->IsConstantOperand()) {
+    int64_t from = ToInteger32(LConstantOperand::cast(instr->from()));
+    int start_offset =
+        FixedDoubleArray::kHeaderSize -
+        kHeapObjectTag + (from << kPointerSizeLog2);
+    if (instr->to()->IsConstantOperand()) {
+      int64_t to = ToInteger32(LConstantOperand::cast(instr->to()));
+      int64_t fill_size = to - from;
+      ASSERT(fill_size >= 0);
+      __ Add(dst, elements, start_offset);
+      int even_fill_size = fill_size & ~1;
+      if (even_fill_size <= LFillElements::kMaxUnrolledSize) {
+        for (int count = 0; count < even_fill_size; count += 2) {
+          __ Stp(value, value, MemOperand(dst, count * kDoubleSize));
+        }
+        if ((fill_size & 1) != 0) {
+          __ Str(value, MemOperand(dst, (fill_size - 1) * kDoubleSize));
+        }
+      } else {
+        remain = temps.AcquireW();
+        __ Mov(remain, even_fill_size);
+        Label loop;
+        __ Bind(&loop);
+        __ Subs(remain, remain, 2);
+        __ Stp(value, value, MemOperand(dst, 2 * kRegisterSize, PostIndex));
+        __ B(ne, &loop);
+        if ((fill_size & 1) != 0) {
+          __ Str(value, MemOperand(dst));
+        }
+      }
+      return;
+    } else {
+      __ Add(dst, elements, start_offset);
+      remain = ToRegister(instr->to()).W();
+      ASSERT(instr->hydrogen()->to()->representation().IsInteger32());
+      if (from > 0) {
+        __ Sub(remain, remain, from);
+      }
+    }
+  } else {
+    remain = temps.AcquireW();
+    Register from = ToRegister(instr->from()).W();
+    ASSERT(instr->hydrogen()->from()->representation().IsInteger32());
+    if (instr->to()->IsConstantOperand()) {
+      int64_t to = ToInteger32(LConstantOperand::cast(instr->to()));
+      __ Mov(remain, to);
+      __ Sub(remain, remain, from);
+    } else {
+      Register to = ToRegister(instr->to()).W();
+      ASSERT(instr->hydrogen()->to()->representation().IsInteger32());
+      __ Sub(remain, to, from);
+    }
+    __ Add(dst, elements, FixedDoubleArray::kHeaderSize - kHeapObjectTag);
+    __ Add(dst, dst, Operand(from, SXTW, kPointerSizeLog2));
+  }
+
+  Label even, loop, done;
+  __ Tbz(remain, 0, &even);
+  __ Sub(remain, remain, 1);
+  __ Str(value, MemOperand(dst, kRegisterSize, PostIndex));
+
+  __ Bind(&even);
+  __ Cbz(remain, &done);
+
+  __ Bind(&loop);
+  __ Subs(remain, remain, 2);
+  __ Stp(value, value, MemOperand(dst, 2 * kRegisterSize, PostIndex));
+  __ B(ne, &loop);
+  __ Bind(&done);
+}
+
+
+void LCodeGen::DoCopyElements(LCopyElements* instr) {
+  Label even, loop, done;
+  UseScratchRegisterScope temps(masm());
+  Register length = ToRegister(instr->length()).W();
+  ASSERT(instr->hydrogen()->length()->representation().IsInteger32());
+
+  Register dst = temps.AcquireX();
+  Register src = temps.AcquireX();
+  __ Add(src, ToRegister(instr->src()),
+         FixedDoubleArray::kHeaderSize - kHeapObjectTag);
+  __ Add(dst, ToRegister(instr->dst()),
+         FixedDoubleArray::kHeaderSize - kHeapObjectTag);
+
+  FPRegister value1 = double_scratch();
+  FPRegister value2 = temps.AcquireD();
+
+  __ Tbz(length, 0, &even);
+  __ Sub(length, length, 1);
+  __ Ldr(value1, MemOperand(src, kRegisterSize, PostIndex));
+  __ Str(value1, MemOperand(dst, kRegisterSize, PostIndex));
+
+  __ Bind(&even);
+  __ Cbz(length, &done);
+
+  __ Bind(&loop);
+  __ Subs(length, length, 2);
+  __ Ldp(value1, value2, MemOperand(src, 2 * kRegisterSize, PostIndex));
+  __ Stp(value1, value2, MemOperand(dst, 2 * kRegisterSize, PostIndex));
+  __ B(ne, &loop);
+  __ Bind(&done);
+}
+
+
 void LCodeGen::DoStoreKeyedExternal(LStoreKeyedExternal* instr) {
   Register ext_ptr = ToRegister(instr->elements());
   Register key = no_reg;
   Register scratch;
   ElementsKind elements_kind = instr->elements_kind();
 
   bool key_is_smi = instr->hydrogen()->key()->representation().IsSmi();
   bool key_is_constant = instr->key()->IsConstantOperand();
   int constant_key = 0;
   if (key_is_constant) {
@@ skipping 875 matching lines @@
   Handle<ScopeInfo> scope_info = instr->scope_info();
   __ Push(scope_info);
   __ Push(ToRegister(instr->function()));
   CallRuntime(Runtime::kHiddenPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 
 } }  // namespace v8::internal