ARM, ARM64: Optimize array copy

src/arm64/lithium-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/lithium-allocator-inl.h"
 #include "src/arm64/lithium-arm64.h"
 #include "src/arm64/lithium-codegen-arm64.h"
 #include "src/hydrogen-osr.h"
@@ skipping 255 matching lines @@
 }
 
 
 void LStoreContextSlot::PrintDataTo(StringStream* stream) {
   context()->PrintTo(stream);
   stream->Add("[%d] <- ", slot_index());
   value()->PrintTo(stream);
 }
 
 
+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 LStoreKeyedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintTo(stream);
   stream->Add("[");
   key()->PrintTo(stream);
   stream->Add("] <- ");
   value()->PrintTo(stream);
 }
 
 
 void LStoreNamedField::PrintDataTo(StringStream* stream) {
@@ skipping 122 matching lines @@
              new(zone()) LUnallocated(LUnallocated::MUST_HAVE_REGISTER,
                                       LUnallocated::USED_AT_START));
 }
 
 
 LOperand* LChunkBuilder::UseRegisterOrConstant(HValue* value) {
   return value->IsConstant() ? UseConstant(value) : UseRegister(value);
 }
 
 
+LOperand* LChunkBuilder::UseRegisterAndClobberOrConstant(HValue* value) {
+  return value->IsConstant()
+      ? UseConstant(value)
+      : UseRegisterAndClobber(value);
+}
+
+
 LOperand* LChunkBuilder::UseRegisterOrConstantAtStart(HValue* value) {
   return value->IsConstant() ? UseConstant(value) : UseRegisterAtStart(value);
 }
 
 
 LConstantOperand* LChunkBuilder::UseConstant(HValue* value) {
   return chunk_->DefineConstantOperand(HConstant::cast(value));
 }
 
 
@@ skipping 1877 matching lines @@
   if (instr->RequiresHoleCheck()) {
     return AssignEnvironment(new(zone()) LStoreGlobalCell(value,
                                                           TempRegister(),
                                                           TempRegister()));
   } else {
     return new(zone()) LStoreGlobalCell(value, TempRegister(), NULL);
   }
 }
 
 
+LInstruction* LChunkBuilder::DoFillElements(HFillElements* instr) {
+  LOperand* elements = UseRegister(instr->elements());
+  LOperand* from = UseRegisterOrConstant(instr->from());
+  LOperand* to = UseRegisterAndClobberOrConstant(instr->to());
+  LOperand* value = UseRegister(instr->value());
+  return new(zone()) LFillElements(elements, from, to, value);
+}
+
+
+LInstruction* LChunkBuilder::DoCopyElements(HCopyElements* instr) {
+  LOperand* src = UseRegister(instr->src());
+  LOperand* dst = UseRegister(instr->dst());
+  LOperand* length = UseRegisterAndClobber(instr->length());
+  return new(zone()) LCopyElements(src, dst, length);
+}
+
+
 LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
   LOperand* key = UseRegisterOrConstant(instr->key());
   LOperand* temp = NULL;
   LOperand* elements = NULL;
   LOperand* val = NULL;
 
   if (!instr->is_typed_elements() &&
       instr->value()->representation().IsTagged() &&
       instr->NeedsWriteBarrier()) {
     // RecordWrite() will clobber all registers.
@@ skipping 391 matching lines @@
     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