*** old/src/share/vm/ci/ciInstanceKlass.hpp	Mon Feb 21 14:15:23 2011
--- new/src/share/vm/ci/ciInstanceKlass.hpp	Mon Feb 21 14:15:23 2011

*** 62,78 ****
--- 62,77 ----
    ciInstanceKlass*       _super;
    ciInstance*            _java_mirror;
  
    ciConstantPoolCache*   _field_cache;  // cached map index->field
    GrowableArray<ciField*>* _nonstatic_fields;
+   GrowableArray<ciField*>* _static_fields;
  
    enum { implementors_limit = instanceKlass::implementors_limit };
    ciInstanceKlass*       _implementors[implementors_limit];
    jint                   _nof_implementors;
  
    GrowableArray<ciField*>* _non_static_fields;
  
  protected:
    ciInstanceKlass(KlassHandle h_k);
    ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);
  
    instanceKlass* get_instanceKlass() const {

*** 96,107 ****
--- 95,106 ----
    bool is_shared() { return _is_shared; }
  
    void compute_shared_init_state();
    bool compute_shared_has_subklass();
    int  compute_shared_nof_implementors();
!   int  compute_nonstatic_fields();
!   GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
!   int  compute_fields();
!   void compute_fields_impl(GrowableArray<ciField*>* super_fields);
  
    // Update the init_state for shared klasses
    void update_if_shared(instanceKlass::ClassState expected) {
      if (_is_shared && _init_state != expected) {
        if (is_loaded()) compute_shared_init_state();

*** 146,164 ****
--- 145,157 ----
    }
    jint                   size_helper()  {
      return (Klass::layout_helper_size_in_bytes(layout_helper())
              >> LogHeapWordSize);
    }
    jint                   nonstatic_field_size()  {
      assert(is_loaded(), "must be loaded");
      return _nonstatic_field_size; }
    jint                   has_nonstatic_fields()  {
      assert(is_loaded(), "must be loaded");
      return _has_nonstatic_fields; }
    jint                   nonstatic_oop_map_size()  {
      assert(is_loaded(), "must be loaded");
      return _nonstatic_oop_map_size; }
    ciInstanceKlass*       super();
    jint                   nof_implementors()  {
      assert(is_loaded(), "must be loaded");
      if (_is_shared)  return compute_shared_nof_implementors();
      return _nof_implementors;

*** 166,195 ****
--- 159,188 ----
  
    ciInstanceKlass* get_canonical_holder(int offset);
    ciField* get_field_by_offset(int field_offset, bool is_static);
    ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);
  
    GrowableArray<ciField*>* non_static_fields();
  
    // total number of nonstatic fields (including inherited):
    int nof_nonstatic_fields() {
      if (_nonstatic_fields == NULL)
        return compute_nonstatic_fields();
      else
        return _nonstatic_fields->length();
+   // All nonstatic fields, including inherited ones
+   GrowableArray<ciField*>* nonstatic_fields() {
+     if (_nonstatic_fields == NULL) {
+       compute_fields();
      }
    // nth nonstatic field (presented by ascending address)
    ciField* nonstatic_field_at(int i) {
      assert(_nonstatic_fields != NULL, "");
      return _nonstatic_fields->at(i);
+     return _nonstatic_fields;
    }
+   // Static fields declared in this class
+   GrowableArray<ciField*>* static_fields() {
+     if (_static_fields == NULL) {
+       compute_fields();
+     }
+     return _static_fields;
+   }
  
    ciInstanceKlass* unique_concrete_subklass();
    bool has_finalizable_subclass();
  
    bool contains_field_offset(int offset) {
!     return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
!     return instanceOopDesc::contains_field_offset(offset, _nonstatic_field_size);
    }
  
    // Get the instance of java.lang.Class corresponding to
    // this klass.  This instance is used for locking of
    // synchronized static methods of this klass.