ARM, ARM64: Optimize array copy

src/arm/lithium-arm.h

 // 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.
 
 #ifndef V8_ARM_LITHIUM_ARM_H_
 #define V8_ARM_LITHIUM_ARM_H_
 
 #include "src/hydrogen.h"
 #include "src/lithium-allocator.h"
 #include "src/lithium.h"
@@ skipping 42 matching lines @@
   V(CmpHoleAndBranch)                           \
   V(CmpMapAndBranch)                            \
   V(CmpT)                                       \
   V(ConstantD)                                  \
   V(ConstantE)                                  \
   V(ConstantI)                                  \
   V(ConstantS)                                  \
   V(ConstantT)                                  \
   V(ConstructDouble)                            \
   V(Context)                                    \
+  V(CopyElements)                               \
   V(DateField)                                  \
   V(DebugBreak)                                 \
   V(DeclareGlobals)                             \
   V(Deoptimize)                                 \
   V(DivByConstI)                                \
   V(DivByPowerOf2I)                             \
   V(DivI)                                       \
   V(DoubleBits)                                 \
   V(DoubleToI)                                  \
   V(DoubleToSmi)                                \
   V(Drop)                                       \
   V(Dummy)                                      \
   V(DummyUse)                                   \
+  V(FillElements)                       \
   V(FlooringDivByConstI)                        \
   V(FlooringDivByPowerOf2I)                     \
   V(FlooringDivI)                               \
   V(ForInCacheArray)                            \
   V(ForInPrepareMap)                            \
   V(FunctionLiteral)                            \
   V(GetCachedArrayIndex)                        \
   V(Goto)                                       \
   V(HasCachedArrayIndexAndBranch)               \
   V(HasInstanceTypeAndBranch)                   \
@@ skipping 2099 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
   DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
 
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 
   Handle<Object> name() const { return hydrogen()->name(); }
   StrictMode strict_mode() { return hydrogen()->strict_mode(); }
 };
 
 
+class LFillElements V8_FINAL : public LTemplateInstruction<0, 4, 1> {
+ public:
+  LFillElements(LOperand* object, LOperand* from, LOperand* to,
+                        LOperand* value, LOperand* scratch) {
+    inputs_[0] = object;
+    inputs_[1] = from;
+    inputs_[2] = to;
+    inputs_[3] = value;
+    temps_[0] = scratch;
+  }
+  LOperand* elements() { return inputs_[0]; }
+  LOperand* from() { return inputs_[1]; }
+  LOperand* to() { return inputs_[2]; }
+  LOperand* value() { return inputs_[3]; }
+  LOperand* scratch() { return temps_[0]; }
+
+  DECLARE_CONCRETE_INSTRUCTION(FillElements, "fill-elements")
+  DECLARE_HYDROGEN_ACCESSOR(FillElements)
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  // Max size for unroll (choosen to generate the smallest code size).
+  static const int32_t kMaxUnrolledSize = 4;
+};
+
+
+class LCopyElements V8_FINAL : public LTemplateInstruction<0, 3, 0> {
+ public:
+  LCopyElements(LOperand* src, LOperand* dst, LOperand* length) {
+    inputs_[0] = src;
+    inputs_[1] = dst;
+    inputs_[2] = length;
+  }
+  LOperand* src() { return inputs_[0]; }
+  LOperand* dst() { return inputs_[1]; }
+  LOperand* length() { return inputs_[2]; }
+  ElementsKind elements_kind() const { return hydrogen()->elements_kind(); }
+
+  DECLARE_CONCRETE_INSTRUCTION(CopyElements, "copy-elements")
+  DECLARE_HYDROGEN_ACCESSOR(CopyElements)
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+};
+
+
 class LStoreKeyed V8_FINAL : public LTemplateInstruction<0, 3, 0> {
  public:
   LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
     inputs_[0] = object;
     inputs_[1] = key;
     inputs_[2] = value;
   }
 
   bool is_external() const { return hydrogen()->is_external(); }
   bool is_fixed_typed_array() const {
@@ skipping 667 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_LITHIUM_ARM_H_