62 flags.set_flags(fi->access_flags());
63 if (flags.field_has_generic_signature()) {
64 length --;
65 skipped_generic_signature_slots ++;
66 }
67 }
68 /* Scan from the current _index. */
69 for (int i = _index; i*FieldInfo::field_slots < length; i++) {
70 fi = FieldInfo::from_field_array(_fields, i);
71 flags.set_flags(fi->access_flags());
72 if (flags.field_has_generic_signature()) {
73 length --;
74 }
75 num_fields ++;
76 }
77 _generic_signature_slot = length + skipped_generic_signature_slots;
78 assert(_generic_signature_slot <= _fields->length(), "");
79 return num_fields;
80 }
81
82 FieldStreamBase(Array<u2>* fields, const constantPoolHandle& constants, int start, int limit) {
83 _fields = fields;
84 _constants = constants;
85 _index = start;
86 int num_fields = init_generic_signature_start_slot();
87 if (limit < start) {
88 _limit = num_fields;
89 } else {
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
130 void set_access_flags(u2 flags) const {
131 field()->set_access_flags(flags);
132 }
133
134 void set_access_flags(AccessFlags flags) const {
135 set_access_flags(flags.as_short());
136 }
137
138 Symbol* name() const {
139 return field()->name(_constants);
140 }
141
142 Symbol* signature() const {
143 return field()->signature(_constants);
144 }
145
146 Symbol* generic_signature() const {
147 if (access_flags().field_has_generic_signature()) {
148 assert(_generic_signature_slot < _fields->length(), "out of bounds");
149 int index = _fields->at(_generic_signature_slot);
150 return _constants->symbol_at(index);
151 } else {
152 return NULL;
153 }
154 }
155
156 int offset() const {
157 return field()->offset();
158 }
159
160 int allocation_type() const {
161 return field()->allocation_type();
162 }
163
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_OOPS_FIELDSTREAMS_HPP
|
62 flags.set_flags(fi->access_flags());
63 if (flags.field_has_generic_signature()) {
64 length --;
65 skipped_generic_signature_slots ++;
66 }
67 }
68 /* Scan from the current _index. */
69 for (int i = _index; i*FieldInfo::field_slots < length; i++) {
70 fi = FieldInfo::from_field_array(_fields, i);
71 flags.set_flags(fi->access_flags());
72 if (flags.field_has_generic_signature()) {
73 length --;
74 }
75 num_fields ++;
76 }
77 _generic_signature_slot = length + skipped_generic_signature_slots;
78 assert(_generic_signature_slot <= _fields->length(), "");
79 return num_fields;
80 }
81
82 inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants, int start, int limit);
83
84 inline FieldStreamBase(Array<u2>* fields, ConstantPool* constants);
85 public:
86 inline FieldStreamBase(InstanceKlass* klass);
87
88 // accessors
89 int index() const { return _index; }
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 int allocation_type() const {
138 return field()->allocation_type();
139 }
140
202 int initval_index() const {
203 assert(!field()->is_internal(), "regular only");
204 return field()->initval_index();
205 }
206 void set_initval_index(int index) {
207 assert(!field()->is_internal(), "regular only");
208 return field()->set_initval_index(index);
209 }
210 };
211
212
213 // Iterate over only the internal fields
214 class InternalFieldStream : public FieldStreamBase {
215 public:
216 InternalFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
217 };
218
219
220 class AllFieldStream : public FieldStreamBase {
221 public:
222 AllFieldStream(Array<u2>* fields, ConstantPool* constants): FieldStreamBase(fields, constants) {}
223 AllFieldStream(InstanceKlass* k): FieldStreamBase(k->fields(), k->constants()) {}
224 };
225
226 #endif // SHARE_OOPS_FIELDSTREAMS_HPP
|