ARM, ARM64: Optimize array copy

src/hydrogen-instructions.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_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 65 matching lines @@
   V(ClassOfTestAndBranch)                      \
   V(CompareNumericAndBranch)                   \
   V(CompareHoleAndBranch)                      \
   V(CompareGeneric)                            \
   V(CompareMinusZeroAndBranch)                 \
   V(CompareObjectEqAndBranch)                  \
   V(CompareMap)                                \
   V(Constant)                                  \
   V(ConstructDouble)                           \
   V(Context)                                   \
+  V(CopyElements)                              \
   V(DateField)                                 \
   V(DebugBreak)                                \
   V(DeclareGlobals)                            \
   V(Deoptimize)                                \
   V(Div)                                       \
   V(DoubleBits)                                \
   V(DummyUse)                                  \
   V(EnterInlined)                              \
   V(EnvironmentMarker)                         \
+  V(FillElements)                              \
   V(ForceRepresentation)                       \
   V(ForInCacheArray)                           \
   V(ForInPrepareMap)                           \
   V(FunctionLiteral)                           \
   V(GetCachedArrayIndex)                       \
   V(Goto)                                      \
   V(HasCachedArrayIndexAndBranch)              \
   V(HasInstanceTypeAndBranch)                  \
   V(InnerAllocatedObject)                      \
   V(InstanceOf)                                \
@@ skipping 5601 matching lines @@
     // Stores to external references require no write barriers
     return false;
   }
   // We definitely need a write barrier unless the object is the allocation
   // dominator.
   if (object == dominator && object->IsAllocate()) {
     // Stores to new space allocations require no write barriers.
     if (HAllocate::cast(object)->IsNewSpaceAllocation()) {
       return false;
     }
-    // Stores to old space allocations require no write barriers if the value is
-    // a constant provably not in new space.
-    if (value->IsConstant() && HConstant::cast(value)->NotInNewSpace()) {
-      return false;
-    }
-    // Stores to old space allocations require no write barriers if the value is
-    // an old space allocation.
-    while (value->IsInnerAllocatedObject()) {
-      value = HInnerAllocatedObject::cast(value)->base_object();
-    }
-    if (value->IsAllocate() &&
-        !HAllocate::cast(value)->IsNewSpaceAllocation()) {
-      return false;
+    if (value != NULL) {
+      // Stores to old space allocations require no write barriers if the value
+      // is a constant provably not in new space.
+      if (value->IsConstant() && HConstant::cast(value)->NotInNewSpace()) {
+        return false;
+      }
+      // Stores to old space allocations require no write barriers if the value
+      // is an old space allocation.
+      while (value->IsInnerAllocatedObject()) {
+        value = HInnerAllocatedObject::cast(value)->base_object();
+      }
+      if (value->IsAllocate() &&
+          !HAllocate::cast(value)->IsNewSpaceAllocation()) {
+        return false;
+      }
     }
   }
   return true;
 }
 
 
 inline PointersToHereCheck PointersToHereCheckForObject(HValue* object,
                                                         HValue* dominator) {
   while (object->IsInnerAllocatedObject()) {
     object = HInnerAllocatedObject::cast(object)->base_object();
@@ skipping 1135 matching lines @@
     SetOperandAt(1, value);
     SetOperandAt(2, context);
     SetAllSideEffects();
   }
 
   Handle<String> name_;
   StrictMode strict_mode_;
 };
 
 
+class HFillElements V8_FINAL : public HTemplateInstruction<4> {
+ public:
+  DECLARE_INSTRUCTION_FACTORY_P4(HFillElements, HValue*, HValue*,
+                                 HValue*, HValue*);
+
+  HValue* elements() { return OperandAt(0); }
+  HValue* from() { return OperandAt(1); }
+  HValue* to() { return OperandAt(2); }
+  HValue* value() { return OperandAt(3); }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  DECLARE_CONCRETE_INSTRUCTION(FillElements)
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    return OperandAt(index)->representation();
+  }
+
+ private:
+  HFillElements(HValue* obj, HValue* from, HValue* to, HValue* val) {
+    SetOperandAt(0, obj);
+    SetOperandAt(1, from);
+    SetOperandAt(2, to);
+    SetOperandAt(3, val);
+  }
+};
+
+
+class HCopyElements V8_FINAL : public HTemplateInstruction<3> {
+ public:
+  DECLARE_INSTRUCTION_FACTORY_P4(HCopyElements, HValue*, HValue*, HValue*,
+                                 ElementsKind);
+
+  HValue* src() { return OperandAt(0); }
+  HValue* dst() { return OperandAt(1); }
+  HValue* length() { return OperandAt(2); }
+  ElementsKind elements_kind() const { return elements_kind_; }
+
+  virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
+
+  DECLARE_CONCRETE_INSTRUCTION(CopyElements)
+
+  virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
+    return OperandAt(index)->representation();
+  }
+
+ private:
+  HCopyElements(HValue* src, HValue* dst, HValue* length,
+                ElementsKind elements_kind)
+      : elements_kind_(elements_kind) {
+    SetOperandAt(0, src);
+    SetOperandAt(1, dst);
+    SetOperandAt(2, length);
+  }
+
+  ElementsKind elements_kind_;
+};
+
+
 class HStoreKeyed V8_FINAL
     : public HTemplateInstruction<3>, public ArrayInstructionInterface {
  public:
   DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind);
   DECLARE_INSTRUCTION_FACTORY_P5(HStoreKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind, StoreFieldOrKeyedMode);
   DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*,
                                  ElementsKind, StoreFieldOrKeyedMode, int);
 
@@ skipping 908 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_