hotspot/src/share/vm/runtime/reflectionUtils.hpp
author sla
Wed, 18 Dec 2013 08:39:06 +0100
changeset 22190 d306a75a70d3
parent 20391 7b146c5ebb18
child 46329 53ccc37bda19
permissions -rw-r--r--
8029726: On OS X some dtrace probe names are mismatched with Solaris 8029727: On OS X dtrace probes Call<type>MethodA/Call<type>MethodV are not fired. 8029728: On OS X dtrace probes SetStaticBooleanField are not fired Reviewed-by: kamg, dsamersoff
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 17031
diff changeset
     2
 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#ifndef SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "oops/objArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "oops/oopsHierarchy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "utilities/accessFlags.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "utilities/globalDefinitions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// A KlassStream is an abstract stream for streaming over self, superclasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// and (super)interfaces. Streaming is done in reverse order (subclasses first,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// interfaces last).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    41
//    for (KlassStream st(k, false, false, false); !st.eos(); st.next()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
    42
//      Klass* k = st.klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//      ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
class KlassStream VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  instanceKlassHandle _klass;           // current klass/interface iterated over
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    49
  instanceKlassHandle _base_klass;      // initial klass/interface to iterate over
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    50
  Array<Klass*>*      _interfaces;      // transitive interfaces for initial class
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  int                 _interface_index; // current interface being processed
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  bool                _local_only;      // process initial class/interface only
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  bool                _classes_only;    // process classes only (no interfaces)
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    54
  bool                _walk_defaults;   // process default methods
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    55
  bool                _base_class_search_defaults; // time to process default methods
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    56
  bool                _defaults_checked; // already checked for default methods
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  int                 _index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    59
  virtual int length() = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // constructor
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    63
  KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only, bool walk_defaults);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  // testing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  bool eos();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  // iterating
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  virtual void next() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  instanceKlassHandle klass() const { return _klass; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  int index() const                 { return _index; }
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    74
  bool base_class_search_defaults() const { return _base_class_search_defaults; }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    75
  void base_class_search_defaults(bool b) { _base_class_search_defaults = b; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
// A MethodStream streams over all methods in a class, superclasses and (super)interfaces.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
// Streaming is done in reverse order (subclasses first, methods in reverse order)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
// Usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
//    for (MethodStream st(k, false, false); !st.eos(); st.next()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
    84
//      Method* m = st.method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
//      ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
//    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
class MethodStream : public KlassStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 private:
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    90
  int length()                    { return methods()->length(); }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    91
  Array<Method*>* methods() {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    92
    if (base_class_search_defaults()) {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    93
      base_class_search_defaults(false);
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    94
      return _klass->default_methods();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    95
    } else {
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    96
      return _klass->methods();
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    97
    }
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
    98
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  MethodStream(instanceKlassHandle klass, bool local_only, bool classes_only)
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   101
    : KlassStream(klass, local_only, classes_only, true) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    _index = length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
    next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  void next() { _index--; }
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   107
  Method* method() { return methods()->at(index()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// A FieldStream streams over all fields in a class, superclasses and (super)interfaces.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
// Streaming is done in reverse order (subclasses first, fields in reverse order)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// Usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
//    for (FieldStream st(k, false, false); !st.eos(); st.next()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   116
//      Symbol* field_name = st.name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
//      ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
//    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
class FieldStream : public KlassStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 private:
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   123
  int length() { return _klass->java_fields_count(); }
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   124
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   125
  fieldDescriptor _fd_buf;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   126
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
20391
7b146c5ebb18 8009130: Lambda: Fix access controls, loader constraints.
acorn
parents: 20017
diff changeset
   129
    : KlassStream(klass, local_only, classes_only, false) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    _index = length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   134
  void next() { _index -= 1; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // Accessors for current field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  AccessFlags access_flags() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    AccessFlags flags;
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   139
    flags.set_flags(_klass->field_access_flags(_index));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    return flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   142
  Symbol* name() const {
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   143
    return _klass->field_name(_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   145
  Symbol* signature() const {
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   146
    return _klass->field_signature(_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // missing: initval()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  int offset() const {
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   150
    return _klass->field_offset( index() );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  }
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   152
  // bridge to a heavier API:
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   153
  fieldDescriptor& field_descriptor() const {
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   154
    fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   155
    field.reinitialize(_klass(), _index);
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   156
    return field;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17376
diff changeset
   157
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 17031
diff changeset
   160
class FilteredField : public CHeapObj<mtInternal>  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
 private:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   162
  Klass* _klass;
17376
4ee999c3c007 8012902: remove use of global operator new - take 2
minqi
parents: 17031
diff changeset
   163
  int    _field_offset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
 public:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   166
  FilteredField(Klass* klass, int field_offset) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    _klass = klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    _field_offset = field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   170
  Klass* klass() { return _klass; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  int  field_offset() { return _field_offset; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
class FilteredFieldsMap : AllStatic {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  static GrowableArray<FilteredField *> *_filtered_fields;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  static void initialize();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   179
  static bool is_filtered_field(Klass* klass, int field_offset) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    for (int i=0; i < _filtered_fields->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      if (klass == _filtered_fields->at(i)->klass() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
        field_offset == _filtered_fields->at(i)->field_offset()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
        return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   188
  static int  filtered_fields_count(Klass* klass, bool local_only) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    int nflds = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    for (int i=0; i < _filtered_fields->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
      if (local_only && klass == _filtered_fields->at(i)->klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
        nflds++;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   193
      } else if (klass->is_subtype_of(_filtered_fields->at(i)->klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
        nflds++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    return nflds;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   199
  // Enhance Class Redefinition Support
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   200
  static void classes_do(KlassClosure* f) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    for (int i = 0; i < _filtered_fields->length(); i++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   202
      f->do_klass(_filtered_fields->at(i)->klass());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
// A FilteredFieldStream streams over all fields in a class, superclasses and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
// (super)interfaces. Streaming is done in reverse order (subclasses first,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
// fields in reverse order)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
// Usage:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
//    for (FilteredFieldStream st(k, false, false); !st.eos(); st.next()) {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   215
//      Symbol* field_name = st.name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
//      ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
//    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
class FilteredFieldStream : public FieldStream {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  int  _filtered_fields_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  bool has_filtered_field() { return (_filtered_fields_count > 0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  FilteredFieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    : FieldStream(klass, local_only, classes_only) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   227
    _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((Klass*)klass(), local_only);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  int field_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  void next() {
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   231
    _index -= 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    if (has_filtered_field()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10546
diff changeset
   233
      while (_index >=0 && FilteredFieldsMap::is_filtered_field((Klass*)_klass(), offset())) {
10546
e79347eebbc5 7086585: make Java field injection more flexible
never
parents: 8921
diff changeset
   234
        _index -= 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   239
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   240
#endif // SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP