ARM, ARM64: Optimize array copy

src/arm/lithium-arm.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/v8.h"
 
 #include "src/lithium-allocator-inl.h"
 #include "src/arm/lithium-arm.h"
 #include "src/arm/lithium-codegen-arm.h"
 #include "src/hydrogen-osr.h"
@@ skipping 326 matching lines @@
   stream->Add("[");
   key()->PrintTo(stream);
   if (hydrogen()->IsDehoisted()) {
     stream->Add(" + %d]", base_offset());
   } else {
     stream->Add("]");
   }
 }
 
 
+void LFillElements::PrintDataTo(StringStream* stream) {
+  elements()->PrintTo(stream);
+  stream->Add("[");
+  from()->PrintTo(stream);
+  stream->Add("-");
+  to()->PrintTo(stream);
+  stream->Add("] <- ");
+  value()->PrintTo(stream);
+}
+
+
+void LCopyElements::PrintDataTo(StringStream* stream) {
+  dst()->PrintTo(stream);
+  stream->Add("[0-");
+  length()->PrintTo(stream);
+  stream->Add("] <- ");
+  src()->PrintTo(stream);
+  stream->Add("[0-");
+  length()->PrintTo(stream);
+  stream->Add("]");
+}
+
+
 void LStoreKeyed::PrintDataTo(StringStream* stream) {
   elements()->PrintTo(stream);
   stream->Add("[");
   key()->PrintTo(stream);
   if (hydrogen()->IsDehoisted()) {
     stream->Add(" + %d] <-", base_offset());
   } else {
     stream->Add("] <- ");
   }
 
@@ skipping 1843 matching lines @@
   LOperand* context = UseFixed(instr->context(), cp);
   LOperand* object = UseFixed(instr->object(), r1);
   LOperand* key = UseFixed(instr->key(), r0);
 
   LInstruction* result =
       DefineFixed(new(zone()) LLoadKeyedGeneric(context, object, key), r0);
   return MarkAsCall(result, instr);
 }
 
 
+LInstruction* LChunkBuilder::DoFillElements(HFillElements* instr) {
+  LOperand* elements = UseRegister(instr->elements());
+  LOperand* from = UseRegisterOrConstant(instr->from());
+  LOperand* to = UseRegisterOrConstant(instr->to());
+  LOperand* value = UseRegister(instr->value());
+  LOperand* scratch;
+  if (instr->from()->IsConstant() && instr->to()->IsConstant()) {
+    HConstant* from = HConstant::cast(instr->from());
+    HConstant* to = HConstant::cast(instr->to());
+    scratch =
+        (to->Integer32Value() - from->Integer32Value() <=
+         LFillElements::kMaxUnrolledSize) ?
+            NULL : TempRegister();
+  } else {
+    scratch = TempRegister();
+  }
+  return new(zone()) LFillElements(elements, from, to, value, scratch);
+}
+
+
+LInstruction* LChunkBuilder::DoCopyElements(HCopyElements* instr) {
+  LOperand* src = UseTempRegister(instr->src());
+  LOperand* dst = UseTempRegister(instr->dst());
+  LOperand* length = UseTempRegister(instr->length());
+  return new(zone()) LCopyElements(src, dst, length);
+}
+
+
 LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
   if (!instr->is_typed_elements()) {
     ASSERT(instr->elements()->representation().IsTagged());
     bool needs_write_barrier = instr->NeedsWriteBarrier();
     LOperand* object = NULL;
     LOperand* key = NULL;
     LOperand* val = NULL;
 
     if (instr->value()->representation().IsDouble()) {
       object = UseRegisterAtStart(instr->elements());
@@ skipping 369 matching lines @@
 LInstruction* LChunkBuilder::DoAllocateBlockContext(
     HAllocateBlockContext* instr) {
   LOperand* context = UseFixed(instr->context(), cp);
   LOperand* function = UseRegisterAtStart(instr->function());
   LAllocateBlockContext* result =
       new(zone()) LAllocateBlockContext(context, function);
   return MarkAsCall(DefineFixed(result, cp), instr);
 }
 
 } }  // namespace v8::internal