1 /*
  2  * Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_OOPS_FIELDSTREAMS_HPP
 26 #define SHARE_OOPS_FIELDSTREAMS_HPP
 27 
 28 #include "oops/instanceKlass.hpp"
 29 #include "oops/fieldInfo.hpp"
 30 #include "runtime/fieldDescriptor.hpp"
 31 
 32 // The is the base class for iteration over the fields array
 33 // describing the declared fields in the class.  Several subclasses
 34 // are provided depending on the kind of iteration required.  The
 35 // JavaFieldStream is for iterating over regular Java fields and it
 36 // generally the preferred iterator.  InternalFieldStream only
 37 // iterates over fields that have been injected by the JVM.
 38 // AllFieldStream exposes all fields and should only be used in rare
 39 // cases.
 40 class FieldStreamBase : public StackObj {

 41  protected:
 42   Array<u2>*          _fields;
 43   constantPoolHandle  _constants;
 44   int                 _index;
 45   int                 _limit;
 46   int                 _generic_signature_slot;
 47   fieldDescriptor     _fd_buf;
 48 
 49   FieldInfo* field() const { return FieldInfo::from_field_array(_fields, _index); }
 50 
 51   int init_generic_signature_start_slot() {
 52     int length = _fields->length();
 53     int num_fields = _index;
 54     int skipped_generic_signature_slots = 0;
 55     FieldInfo* fi;
 56     AccessFlags flags;
 57     /* Scan from 0 to the current _index. Count the number of generic
 58        signature slots for field[0] to field[_index - 1]. */
 59     for (int i = 0; i < _index; i++) {
 60       fi = FieldInfo::from_field_array(_fields, i);
 61       flags.set_flags(fi->access_flags());
 62       if (flags.field_has_generic_signature()) {
 63         length --;
 64         skipped_generic_signature_slots ++;
 65       }
 66     }
 67     /* Scan from the current _index. */
 68     for (int i = _index; i*FieldInfo::field_slots < length; i++) {
 69       fi = FieldInfo::from_field_array(_fields, i);
 70       flags.set_flags(fi->access_flags());
 71       if (flags.field_has_generic_signature()) {
 72         length --;
 73       }
 74       num_fields ++;
 75     }
 76     _generic_signature_slot = length + skipped_generic_signature_slots;
 77     assert(_generic_signature_slot <= _fields->length(), "");
 78     return num_fields;
 79   }
 80 
 81   inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants, int start, int limit);
 82 
 83   inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants);
 84  public:
 85   inline FieldStreamBase(InstanceKlass* klass);
 86 
 87   // accessors
 88   int index() const                 { return _index; }
 89   InstanceKlass* field_holder() const { return _constants->pool_holder(); }
 90 
 91   void next() {
 92     if (access_flags().field_has_generic_signature()) {
 93       _generic_signature_slot ++;
 94       assert(_generic_signature_slot <= _fields->length(), "");
 95     }
 96     _index += 1;
 97   }
 98   bool done() const { return _index >= _limit; }
 99 
100   // Accessors for current field
101   AccessFlags access_flags() const {
102     AccessFlags flags;
103     flags.set_flags(field()->access_flags());
104     return flags;
105   }
106 
107   void set_access_flags(u2 flags) const {
108     field()->set_access_flags(flags);
109   }
110 
111   void set_access_flags(AccessFlags flags) const {
112     set_access_flags(flags.as_short());
113   }
114 
115   Symbol* name() const {
116     return field()->name(_constants());
117   }
118 
119   Symbol* signature() const {
120     return field()->signature(_constants());
121   }
122 
123   Symbol* generic_signature() const {
124     if (access_flags().field_has_generic_signature()) {
125       assert(_generic_signature_slot < _fields->length(), "out of bounds");
126       int index = _fields->at(_generic_signature_slot);
127       return _constants->symbol_at(index);
128     } else {
129       return NULL;
130     }
131   }
132 
133   int offset() const {
134     return field()->offset();
135   }
136 








137   void set_offset(int offset) {
138     field()->set_offset(offset);
139   }
140 
141   bool is_offset_set() const {
142     return field()->is_offset_set();
143   }
144 
145   bool is_contended() const {
146     return field()->is_contended();
147   }
148 
149   int contended_group() const {
150     return field()->contended_group();
151   }
152 
153   // bridge to a heavier API:
154   fieldDescriptor& field_descriptor() const {
155     fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
156     field.reinitialize(field_holder(), _index);
157     return field;
158   }
159 };
160 
161 // Iterate over only the internal fields
162 class JavaFieldStream : public FieldStreamBase {
163  public:
164   JavaFieldStream(const InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), 0, k->java_fields_count()) {}
165 
166   int name_index() const {
167     assert(!field()->is_internal(), "regular only");
168     return field()->name_index();
169   }
170   void set_name_index(int index) {
171     assert(!field()->is_internal(), "regular only");
172     field()->set_name_index(index);
173   }
174   int signature_index() const {
175     assert(!field()->is_internal(), "regular only");
176     return field()->signature_index();
177   }
178   void set_signature_index(int index) {
179     assert(!field()->is_internal(), "regular only");
180     field()->set_signature_index(index);
181   }
182   int generic_signature_index() const {
183     assert(!field()->is_internal(), "regular only");
184     if (access_flags().field_has_generic_signature()) {
185       assert(_generic_signature_slot < _fields->length(), "out of bounds");
186       return _fields->at(_generic_signature_slot);
187     } else {
188       return 0;
189     }
190   }
191   void set_generic_signature_index(int index) {
192     assert(!field()->is_internal(), "regular only");
193     if (access_flags().field_has_generic_signature()) {
194       assert(_generic_signature_slot < _fields->length(), "out of bounds");
195       _fields->at_put(_generic_signature_slot, index);
196     }
197   }
198   int initval_index() const {
199     assert(!field()->is_internal(), "regular only");
200     return field()->initval_index();
201   }
202   void set_initval_index(int index) {
203     assert(!field()->is_internal(), "regular only");
204     return field()->set_initval_index(index);
205   }
206 };
207 
208 
209 // Iterate over only the internal fields
210 class InternalFieldStream : public FieldStreamBase {
211  public:
212   InternalFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
213 };
214 
215 
216 class AllFieldStream : public FieldStreamBase {
217  public:
218   AllFieldStream(Array<u2>* fields, ConstantPool* constants): FieldStreamBase(fields, constants) {}
219   AllFieldStream(InstanceKlass* k):      FieldStreamBase(k->fields(), k->constants()) {}
220 };
221 
222 #endif // SHARE_OOPS_FIELDSTREAMS_HPP
--- EOF ---