90 _limit = limit;
91 }
92 }
93
94 FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants) {
95 _fields = fields;
96 _constants = constants;
97 _index = 0;
98 _limit = init_generic_signature_start_slot();
99 }
100
101 public:
102 FieldStreamBase(InstanceKlass* klass) {
103 _fields = klass->fields();
104 _constants = klass->constants();
105 _index = 0;
106 _limit = klass->java_fields_count();
107 init_generic_signature_start_slot();
108 assert(klass == field_holder(), "");
109 }
110 FieldStreamBase(instanceKlassHandle klass) {
111 _fields = klass->fields();
112 _constants = klass->constants();
113 _index = 0;
114 _limit = klass->java_fields_count();
115 init_generic_signature_start_slot();
116 assert(klass == field_holder(), "");
117 }
118
119 // accessors
120 int index() const { return _index; }
121
122 void next() {
123 if (access_flags().field_has_generic_signature()) {
124 _generic_signature_slot ++;
125 assert(_generic_signature_slot <= _fields->length(), "");
126 }
127 _index += 1;
128 }
129 bool done() const { return _index >= _limit; }
130
131 // Accessors for current field
132 AccessFlags access_flags() const {
133 AccessFlags flags;
134 flags.set_flags(field()->access_flags());
135 return flags;
136 }
137
179
180 bool is_contended() const {
181 return field()->is_contended();
182 }
183
184 int contended_group() const {
185 return field()->contended_group();
186 }
187
188 // bridge to a heavier API:
189 fieldDescriptor& field_descriptor() const {
190 fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
191 field.reinitialize(field_holder(), _index);
192 return field;
193 }
194 };
195
196 // Iterate over only the internal fields
197 class JavaFieldStream : public FieldStreamBase {
198 public:
199 JavaFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), 0, k->java_fields_count()) {}
200
201 int name_index() const {
202 assert(!field()->is_internal(), "regular only");
203 return field()->name_index();
204 }
205 void set_name_index(int index) {
206 assert(!field()->is_internal(), "regular only");
207 field()->set_name_index(index);
208 }
209 int signature_index() const {
210 assert(!field()->is_internal(), "regular only");
211 return field()->signature_index();
212 }
213 void set_signature_index(int index) {
214 assert(!field()->is_internal(), "regular only");
215 field()->set_signature_index(index);
216 }
217 int generic_signature_index() const {
218 assert(!field()->is_internal(), "regular only");
219 if (access_flags().field_has_generic_signature()) {
228 if (access_flags().field_has_generic_signature()) {
229 assert(_generic_signature_slot < _fields->length(), "out of bounds");
230 _fields->at_put(_generic_signature_slot, index);
231 }
232 }
233 int initval_index() const {
234 assert(!field()->is_internal(), "regular only");
235 return field()->initval_index();
236 }
237 void set_initval_index(int index) {
238 assert(!field()->is_internal(), "regular only");
239 return field()->set_initval_index(index);
240 }
241 };
242
243
244 // Iterate over only the internal fields
245 class InternalFieldStream : public FieldStreamBase {
246 public:
247 InternalFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
248 InternalFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
249 };
250
251
252 class AllFieldStream : public FieldStreamBase {
253 public:
254 AllFieldStream(Array<u2>* fields, const constantPoolHandle& constants): FieldStreamBase(fields, constants) {}
255 AllFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants()) {}
256 AllFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants()) {}
257 };
258
259 #endif // SHARE_VM_OOPS_FIELDSTREAMS_HPP
|
90 _limit = limit;
91 }
92 }
93
94 FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants) {
95 _fields = fields;
96 _constants = constants;
97 _index = 0;
98 _limit = init_generic_signature_start_slot();
99 }
100
101 public:
102 FieldStreamBase(InstanceKlass* klass) {
103 _fields = klass->fields();
104 _constants = klass->constants();
105 _index = 0;
106 _limit = klass->java_fields_count();
107 init_generic_signature_start_slot();
108 assert(klass == field_holder(), "");
109 }
110
111 // accessors
112 int index() const { return _index; }
113
114 void next() {
115 if (access_flags().field_has_generic_signature()) {
116 _generic_signature_slot ++;
117 assert(_generic_signature_slot <= _fields->length(), "");
118 }
119 _index += 1;
120 }
121 bool done() const { return _index >= _limit; }
122
123 // Accessors for current field
124 AccessFlags access_flags() const {
125 AccessFlags flags;
126 flags.set_flags(field()->access_flags());
127 return flags;
128 }
129
171
172 bool is_contended() const {
173 return field()->is_contended();
174 }
175
176 int contended_group() const {
177 return field()->contended_group();
178 }
179
180 // bridge to a heavier API:
181 fieldDescriptor& field_descriptor() const {
182 fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
183 field.reinitialize(field_holder(), _index);
184 return field;
185 }
186 };
187
188 // Iterate over only the internal fields
189 class JavaFieldStream : public FieldStreamBase {
190 public:
191 JavaFieldStream(const InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), 0, k->java_fields_count()) {}
192
193 int name_index() const {
194 assert(!field()->is_internal(), "regular only");
195 return field()->name_index();
196 }
197 void set_name_index(int index) {
198 assert(!field()->is_internal(), "regular only");
199 field()->set_name_index(index);
200 }
201 int signature_index() const {
202 assert(!field()->is_internal(), "regular only");
203 return field()->signature_index();
204 }
205 void set_signature_index(int index) {
206 assert(!field()->is_internal(), "regular only");
207 field()->set_signature_index(index);
208 }
209 int generic_signature_index() const {
210 assert(!field()->is_internal(), "regular only");
211 if (access_flags().field_has_generic_signature()) {
220 if (access_flags().field_has_generic_signature()) {
221 assert(_generic_signature_slot < _fields->length(), "out of bounds");
222 _fields->at_put(_generic_signature_slot, index);
223 }
224 }
225 int initval_index() const {
226 assert(!field()->is_internal(), "regular only");
227 return field()->initval_index();
228 }
229 void set_initval_index(int index) {
230 assert(!field()->is_internal(), "regular only");
231 return field()->set_initval_index(index);
232 }
233 };
234
235
236 // Iterate over only the internal fields
237 class InternalFieldStream : public FieldStreamBase {
238 public:
239 InternalFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
240 };
241
242
243 class AllFieldStream : public FieldStreamBase {
244 public:
245 AllFieldStream(Array<u2>* fields, const constantPoolHandle& constants): FieldStreamBase(fields, constants) {}
246 AllFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants()) {}
247 };
248
249 #endif // SHARE_VM_OOPS_FIELDSTREAMS_HPP
|