src/hotspot/share/opto/arraycopynode.hpp
changeset 59324 5e8f9713e343
parent 58931 304c63b17b07
equal deleted inserted replaced
59323:ae2eb76c486d 59324:5e8f9713e343
    35 
    35 
    36   // What kind of arraycopy variant is this?
    36   // What kind of arraycopy variant is this?
    37   enum {
    37   enum {
    38     None,            // not set yet
    38     None,            // not set yet
    39     ArrayCopy,       // System.arraycopy()
    39     ArrayCopy,       // System.arraycopy()
    40     CloneBasic,      // A clone that can be copied by 64 bit chunks
    40     CloneInst,       // A clone of instances
    41     CloneOopArray,   // An oop array clone
    41     CloneArray,      // A clone of arrays that don't require a barrier
       
    42                      // - depends on GC - some need to treat oop arrays separately
       
    43     CloneOopArray,   // An oop array clone that requires GC barriers
    42     CopyOf,          // Arrays.copyOf()
    44     CopyOf,          // Arrays.copyOf()
    43     CopyOfRange      // Arrays.copyOfRange()
    45     CopyOfRange      // Arrays.copyOfRange()
    44   } _kind;
    46   } _kind;
    45 
    47 
    46 #ifndef PRODUCT
    48 #ifndef PRODUCT
   144 
   146 
   145   void connect_outputs(GraphKit* kit);
   147   void connect_outputs(GraphKit* kit);
   146 
   148 
   147   bool is_arraycopy()             const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy; }
   149   bool is_arraycopy()             const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy; }
   148   bool is_arraycopy_validated()   const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy && _arguments_validated; }
   150   bool is_arraycopy_validated()   const  { assert(_kind != None, "should bet set"); return _kind == ArrayCopy && _arguments_validated; }
   149   bool is_clonebasic()            const  { assert(_kind != None, "should bet set"); return _kind == CloneBasic; }
   151   bool is_clone_inst()            const  { assert(_kind != None, "should bet set"); return _kind == CloneInst; }
       
   152   // is_clone_array - true for all arrays when using GCs that has no barriers
       
   153   bool is_clone_array()           const  { assert(_kind != None, "should bet set"); return _kind == CloneArray; }
       
   154   // is_clone_oop_array is used when oop arrays need GC barriers
   150   bool is_clone_oop_array()       const  { assert(_kind != None, "should bet set"); return _kind == CloneOopArray; }
   155   bool is_clone_oop_array()       const  { assert(_kind != None, "should bet set"); return _kind == CloneOopArray; }
       
   156   // is_clonebasic - is true for any type of clone that doesn't need a barrier.
       
   157   bool is_clonebasic()            const  { assert(_kind != None, "should bet set"); return _kind == CloneInst || _kind == CloneArray; }
   151   bool is_copyof()                const  { assert(_kind != None, "should bet set"); return _kind == CopyOf; }
   158   bool is_copyof()                const  { assert(_kind != None, "should bet set"); return _kind == CopyOf; }
   152   bool is_copyof_validated()      const  { assert(_kind != None, "should bet set"); return _kind == CopyOf && _arguments_validated; }
   159   bool is_copyof_validated()      const  { assert(_kind != None, "should bet set"); return _kind == CopyOf && _arguments_validated; }
   153   bool is_copyofrange()           const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange; }
   160   bool is_copyofrange()           const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange; }
   154   bool is_copyofrange_validated() const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange && _arguments_validated; }
   161   bool is_copyofrange_validated() const  { assert(_kind != None, "should bet set"); return _kind == CopyOfRange && _arguments_validated; }
   155 
   162 
   156   void set_arraycopy(bool validated)   { assert(_kind == None, "shouldn't bet set yet"); _kind = ArrayCopy; _arguments_validated = validated; }
   163   void set_arraycopy(bool validated)   { assert(_kind == None, "shouldn't bet set yet"); _kind = ArrayCopy; _arguments_validated = validated; }
   157   void set_clonebasic()                { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneBasic; }
   164   void set_clone_inst()                { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneInst; }
       
   165   void set_clone_array()               { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneArray; }
   158   void set_clone_oop_array()           { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneOopArray; }
   166   void set_clone_oop_array()           { assert(_kind == None, "shouldn't bet set yet"); _kind = CloneOopArray; }
   159   void set_copyof(bool validated)      { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOf; _arguments_validated = validated; }
   167   void set_copyof(bool validated)      { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOf; _arguments_validated = validated; }
   160   void set_copyofrange(bool validated) { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOfRange; _arguments_validated = validated; }
   168   void set_copyofrange(bool validated) { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOfRange; _arguments_validated = validated; }
   161 
   169 
   162   virtual int Opcode() const;
   170   virtual int Opcode() const;