ARM, ARM64: Optimize array copy

src/arm64/lithium-arm64.h

 // 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.
 
 #ifndef V8_ARM64_LITHIUM_ARM64_H_
 #define V8_ARM64_LITHIUM_ARM64_H_
 
 #include "src/hydrogen.h"
 #include "src/lithium-allocator.h"
 #include "src/lithium.h"
@@ skipping 46 matching lines @@
   V(CmpT)                                       \
   V(CompareMinusZeroAndBranch)                  \
   V(CompareNumericAndBranch)                    \
   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(DoubleToIntOrSmi)                           \
   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 2331 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")
   DECLARE_HYDROGEN_ACCESSOR(StackCheck)
 
   Label* done_label() { return &done_label_; }
 
  private:
   Label done_label_;
 };
 
 
+class LFillElements V8_FINAL : public LTemplateInstruction<0, 4, 0> {
+ public:
+  LFillElements(LOperand* object, LOperand* from, LOperand* to,
+                        LOperand* value) {
+    inputs_[0] = object;
+    inputs_[1] = from;
+    inputs_[2] = to;
+    inputs_[3] = value;
+  }
+  LOperand* elements() { return inputs_[0]; }
+  LOperand* from() { return inputs_[1]; }
+  LOperand* to() { return inputs_[2]; }
+  LOperand* value() { return inputs_[3]; }
+
+  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 = 8;
+};
+
+
+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]; }
+
+  DECLARE_CONCRETE_INSTRUCTION(CopyElements, "copy-elements")
+  DECLARE_HYDROGEN_ACCESSOR(CopyElements)
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+};
+
+
 template<int T>
 class LStoreKeyed : public LTemplateInstruction<0, 3, T> {
  public:
   LStoreKeyed(LOperand* elements, LOperand* key, LOperand* value) {
     this->inputs_[0] = elements;
     this->inputs_[1] = key;
     this->inputs_[2] = value;
   }
 
   bool is_external() const { return this->hydrogen()->is_external(); }
@@ skipping 694 matching lines @@
   MUST_USE_RESULT LOperand* UseRegisterAndClobber(HValue* value);
 
   // The operand created by UseRegisterAtStart is guaranteed to be live only at
   // instruction start. The register allocator is free to assign the same
   // register to some other operand used inside instruction (i.e. temporary or
   // output).
   MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value);
 
   // An input operand in a register or a constant operand.
   MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value);
+  MUST_USE_RESULT LOperand* UseRegisterAndClobberOrConstant(HValue* value);
   MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value);
 
   // A constant operand.
   MUST_USE_RESULT LConstantOperand* UseConstant(HValue* value);
 
   // An input operand in register, stack slot or a constant operand.
   // Will not be moved to a register even if one is freely available.
   virtual MUST_USE_RESULT LOperand* UseAny(HValue* value);
 
   // Temporary operand that must be in a register.
@@ skipping 85 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_LITHIUM_ARM64_H_