src/share/vm/opto/callnode.hpp

rev 7687 : 6912521: System.arraycopy works slower than the simple loop for little lengths
Summary: convert small array copies to series of loads and stores
Reviewed-by:

*** 1118,1131 ****
--- 1118,1148 ----
      return TypeFunc::make(domain, range);
    }
  
    ArrayCopyNode(Compile* C, bool alloc_tightly_coupled);
  
+   intptr_t get_length_if_constant(PhaseGVN *phase) const;
    int get_count(PhaseGVN *phase) const;
    static const TypePtr* get_address_type(PhaseGVN *phase, Node* n);
  
    Node* try_clone_instance(PhaseGVN *phase, bool can_reshape, int count);
+   Node* conv_I2X_offset(PhaseGVN *phase, Node* offset, const TypeAryPtr* ary_t);
+   bool prepare_array_copy(PhaseGVN *phase, bool can_reshape,
+                           Node*& adr_src, Node*& base_src, Node*& adr_dest, Node*& base_dest,
+                           BasicType& copy_type, const Type*& value_type, bool& disjoint_bases);
+   void array_copy_test_overlap(PhaseGVN *phase, bool can_reshape,
+                                bool disjoint_bases, Node*& forward_ctl, Node*& backward_ctl);
+   Node* array_copy_forward(PhaseGVN *phase, bool can_reshape, Node* ctl,
+                            Node* start_mem_src, Node* start_mem_dest,
+                            const TypePtr* atp_src, const TypePtr* atp_dest,
+                            Node* adr_src, Node* base_src, Node* adr_dest, Node* base_dest,
+                            BasicType copy_type, const Type* value_type, int count);
+   Node* array_copy_backward(PhaseGVN *phase, bool can_reshape, Node* ctl,
+                             Node *start_mem_src, Node* start_mem_dest,
+                             const TypePtr* atp_src, const TypePtr* atp_dest,
+                             Node* adr_src, Node* base_src, Node* adr_dest, Node* base_dest,
+                             BasicType copy_type, const Type* value_type, int count);
    bool finish_transform(PhaseGVN *phase, bool can_reshape,
                          Node* ctl, Node *mem);
  
  public:
  
*** 1155,1171 ****
    bool is_arraycopy()             const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy; }
    bool is_arraycopy_validated()   const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy && _arguments_validated; }
    bool is_clonebasic()            const  { assert(_kind != None, "should bet set"); return _kind == CloneBasic; }
    bool is_cloneoop()              const  { assert(_kind != None, "should bet set"); return _kind == CloneOop; }
    bool is_copyof()                const  { assert(_kind != None, "should bet set"); return _kind == CopyOf; }
    bool is_copyofrange()           const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange; }
  
    void set_arraycopy(bool validated)   { assert(_kind == None, "shouldn't bet set yet"); _kind = ArrayCopy; _arguments_validated = validated; }
    void set_clonebasic()                { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneBasic; }
    void set_cloneoop()                  { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneOop; }
!   void set_copyof()                    { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOf; _arguments_validated = false; }
!   void set_copyofrange()               { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOfRange; _arguments_validated = false; }
  
    virtual int Opcode() const;
    virtual uint size_of() const; // Size is bigger
    virtual bool guaranteed_safepoint()  { return false; }
    virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
--- 1172,1190 ----
    bool is_arraycopy()             const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy; }
    bool is_arraycopy_validated()   const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy && _arguments_validated; }
    bool is_clonebasic()            const  { assert(_kind != None, "should bet set"); return _kind == CloneBasic; }
    bool is_cloneoop()              const  { assert(_kind != None, "should bet set"); return _kind == CloneOop; }
    bool is_copyof()                const  { assert(_kind != None, "should bet set"); return _kind == CopyOf; }
+   bool is_copyof_validated()      const  { assert(_kind != None, "should bet set"); return _kind == CopyOf && _arguments_validated; }
    bool is_copyofrange()           const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange; }
+   bool is_copyofrange_validated() const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange && _arguments_validated; }
  
    void set_arraycopy(bool validated)   { assert(_kind == None, "shouldn't bet set yet"); _kind = ArrayCopy; _arguments_validated = validated; }
    void set_clonebasic()                { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneBasic; }
    void set_cloneoop()                  { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneOop; }
!   void set_copyof(bool validated)      { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOf; _arguments_validated = validated; }
!   void set_copyofrange(bool validated) { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOfRange; _arguments_validated = validated; }
  
    virtual int Opcode() const;
    virtual uint size_of() const; // Size is bigger
    virtual bool guaranteed_safepoint()  { return false; }
    virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);