src/hotspot/share/oops/arrayKlass.hpp

*** 41,19 ***
--- 41,40 ---
    int      _dimension;         // This is n'th-dimensional array.
    ObjArrayKlass* volatile _higher_dimension;  // Refers the (n+1)'th-dimensional array (if present).
    ArrayKlass* volatile    _lower_dimension;   // Refers the (n-1)'th-dimensional array (if present).
  
   protected:
+   Klass* _element_klass;            // The klass of the elements of this array type
+                                     // The element type must be registered for both object arrays
+                                     // (incl. object arrays with value type elements) and value type
+                                     // arrays containing flat value types. However, the element
+                                     // type must not be registered for arrays of primitive types.
+                                     // TODO: Update the class hierarchy so that element klass appears
+                                     // only in array that contain non-primitive types.
    // Constructors
    // The constructor with the Symbol argument does the real array
    // initialization, the other is a dummy
    ArrayKlass(Symbol* name, KlassKind kind);
    ArrayKlass();
  
+   // Create array_name for element klass
+   static Symbol* create_element_klass_array_name(Klass* element_klass, TRAPS);
+ 
    void* operator new(size_t size, ClassLoaderData* loader_data, size_t word_size, TRAPS) throw();
  
   public:
+   // Instance variables
+   virtual Klass* element_klass() const      { return _element_klass; }
+   virtual void set_element_klass(Klass* k)  { _element_klass = k; }
+ 
+   // Compiler/Interpreter offset
+   static ByteSize element_klass_offset() { return in_ByteSize(offset_of(ArrayKlass, _element_klass)); }
+ 
+   // Are loads and stores to this concrete array type atomic?
+   // Note that Object[] is naturally atomic, but its subtypes may not be.
+   virtual bool element_access_must_be_atomic() { return true; }
+ 
    // Testing operation
    DEBUG_ONLY(bool is_array_klass_slow() const { return true; })
  
    // Returns the ObjArrayKlass for n'th dimension.
    ArrayKlass* array_klass(int n, TRAPS);

*** 108,10 ***
--- 129,12 ---
    }
  
    GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots,
                                                    Array<InstanceKlass*>* transitive_interfaces);
  
+   oop component_mirror() const;
+ 
    // Sizing
    static int static_size(int header_size);
  
    virtual void metaspace_pointers_do(MetaspaceClosure* iter);