Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/oops/fieldStreams.hpp

src/share/vm/oops/fieldStreams.hpp

changeset 3803
71afdabfd05b
parent 3137
e6b1331a51d2
child 4037
da91efe96a93
equal deleted inserted replaced
3772:03d61caacd1e 3803:71afdabfd05b
40 protected: 40 protected:
41 typeArrayHandle _fields; 41 typeArrayHandle _fields;
42 constantPoolHandle _constants; 42 constantPoolHandle _constants;
43 int _index; 43 int _index;
44 int _limit; 44 int _limit;
45 int _generic_signature_slot;
45 46
46 FieldInfo* field() const { return FieldInfo::from_field_array(_fields(), _index); } 47 FieldInfo* field() const { return FieldInfo::from_field_array(_fields(), _index); }
48
49 int init_generic_signature_start_slot() {
50 int length = _fields->length();
51 int num_fields = 0;
52 int skipped_generic_signature_slots = 0;
53 FieldInfo* fi;
54 AccessFlags flags;
55 /* Scan from 0 to the current _index. Count the number of generic
56 signature slots for field[0] to field[_index - 1]. */
57 for (int i = 0; i < _index; i++) {
58 fi = FieldInfo::from_field_array(_fields(), i);
59 flags.set_flags(fi->access_flags());
60 if (flags.field_has_generic_signature()) {
61 length --;
62 skipped_generic_signature_slots ++;
63 }
64 }
65 /* Scan from the current _index. */
66 for (int i = _index; i*FieldInfo::field_slots < length; i++) {
67 fi = FieldInfo::from_field_array(_fields(), i);
68 flags.set_flags(fi->access_flags());
69 if (flags.field_has_generic_signature()) {
70 length --;
71 }
72 num_fields ++;
73 }
74 _generic_signature_slot = length + skipped_generic_signature_slots;
75 assert(_generic_signature_slot <= _fields->length(), "");
76 return num_fields;
77 }
47 78
48 FieldStreamBase(typeArrayHandle fields, constantPoolHandle constants, int start, int limit) { 79 FieldStreamBase(typeArrayHandle fields, constantPoolHandle constants, int start, int limit) {
49 _fields = fields; 80 _fields = fields;
50 _constants = constants; 81 _constants = constants;
51 _index = start; 82 _index = start;
52 _limit = limit; 83 int num_fields = init_generic_signature_start_slot();
84 if (limit < start) {
85 _limit = num_fields;
86 } else {
87 _limit = limit;
88 }
53 } 89 }
54 90
55 FieldStreamBase(typeArrayHandle fields, constantPoolHandle constants) { 91 FieldStreamBase(typeArrayHandle fields, constantPoolHandle constants) {
56 _fields = fields; 92 _fields = fields;
57 _constants = constants; 93 _constants = constants;
58 _index = 0; 94 _index = 0;
59 _limit = fields->length() / FieldInfo::field_slots; 95 _limit = init_generic_signature_start_slot();
60 } 96 }
61 97
62 public: 98 public:
63 FieldStreamBase(instanceKlass* klass) { 99 FieldStreamBase(instanceKlass* klass) {
64 _fields = klass->fields(); 100 _fields = klass->fields();
65 _constants = klass->constants(); 101 _constants = klass->constants();
66 _index = 0; 102 _index = 0;
67 _limit = klass->java_fields_count(); 103 _limit = klass->java_fields_count();
104 init_generic_signature_start_slot();
68 } 105 }
69 FieldStreamBase(instanceKlassHandle klass) { 106 FieldStreamBase(instanceKlassHandle klass) {
70 _fields = klass->fields(); 107 _fields = klass->fields();
71 _constants = klass->constants(); 108 _constants = klass->constants();
72 _index = 0; 109 _index = 0;
73 _limit = klass->java_fields_count(); 110 _limit = klass->java_fields_count();
111 init_generic_signature_start_slot();
74 } 112 }
75 113
76 // accessors 114 // accessors
77 int index() const { return _index; } 115 int index() const { return _index; }
78 116
79 void next() { _index += 1; } 117 void next() {
118 if (access_flags().field_has_generic_signature()) {
119 _generic_signature_slot ++;
120 assert(_generic_signature_slot <= _fields->length(), "");
121 }
122 _index += 1;
123 }
80 bool done() const { return _index >= _limit; } 124 bool done() const { return _index >= _limit; }
81 125
82 // Accessors for current field 126 // Accessors for current field
83 AccessFlags access_flags() const { 127 AccessFlags access_flags() const {
84 AccessFlags flags; 128 AccessFlags flags;
101 Symbol* signature() const { 145 Symbol* signature() const {
102 return field()->signature(_constants); 146 return field()->signature(_constants);
103 } 147 }
104 148
105 Symbol* generic_signature() const { 149 Symbol* generic_signature() const {
106 return field()->generic_signature(_constants); 150 if (access_flags().field_has_generic_signature()) {
151 assert(_generic_signature_slot < _fields->length(), "out of bounds");
152 int index = _fields->short_at(_generic_signature_slot);
153 return _constants->symbol_at(index);
154 } else {
155 return NULL;
156 }
107 } 157 }
108 158
109 int offset() const { 159 int offset() const {
110 return field()->offset(); 160 return field()->offset();
111 } 161 }
137 assert(!field()->is_internal(), "regular only"); 187 assert(!field()->is_internal(), "regular only");
138 field()->set_signature_index(index); 188 field()->set_signature_index(index);
139 } 189 }
140 int generic_signature_index() const { 190 int generic_signature_index() const {
141 assert(!field()->is_internal(), "regular only"); 191 assert(!field()->is_internal(), "regular only");
142 return field()->generic_signature_index(); 192 if (access_flags().field_has_generic_signature()) {
193 assert(_generic_signature_slot < _fields->length(), "out of bounds");
194 return _fields->short_at(_generic_signature_slot);
195 } else {
196 return 0;
197 }
143 } 198 }
144 void set_generic_signature_index(int index) { 199 void set_generic_signature_index(int index) {
145 assert(!field()->is_internal(), "regular only"); 200 assert(!field()->is_internal(), "regular only");
146 field()->set_generic_signature_index(index); 201 if (access_flags().field_has_generic_signature()) {
202 assert(_generic_signature_slot < _fields->length(), "out of bounds");
203 _fields->short_at_put(_generic_signature_slot, index);
204 }
147 } 205 }
148 int initval_index() const { 206 int initval_index() const {
149 assert(!field()->is_internal(), "regular only"); 207 assert(!field()->is_internal(), "regular only");
150 return field()->initval_index(); 208 return field()->initval_index();
151 } 209 }
157 215
158 216
159 // Iterate over only the internal fields 217 // Iterate over only the internal fields
160 class InternalFieldStream : public FieldStreamBase { 218 class InternalFieldStream : public FieldStreamBase {
161 public: 219 public:
162 InternalFieldStream(instanceKlass* k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), k->all_fields_count()) {} 220 InternalFieldStream(instanceKlass* k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
163 InternalFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), k->all_fields_count()) {} 221 InternalFieldStream(instanceKlassHandle k): FieldStreamBase(k->fields(), k->constants(), k->java_fields_count(), 0) {}
164 }; 222 };
165 223
166 224
167 class AllFieldStream : public FieldStreamBase { 225 class AllFieldStream : public FieldStreamBase {
168 public: 226 public:

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial