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_FIELDINFO_INLINE_HPP
26 #define SHARE_OOPS_FIELDINFO_INLINE_HPP
27
28 #include "oops/fieldInfo.hpp"
29
30 #include "memory/metadataFactory.hpp"
31 #include "oops/constantPool.hpp"
32 #include "oops/symbol.hpp"
33 #include "runtime/atomicAccess.hpp"
34 #include "utilities/checkedCast.hpp"
35
36 inline Symbol* FieldInfo::name(ConstantPool* cp) const {
37 int index = _name_index;
38 if (_field_flags.is_injected()) {
39 return lookup_symbol(index);
40 }
41 return cp->symbol_at(index);
42 }
43
44 inline Symbol* FieldInfo::signature(ConstantPool* cp) const {
45 int index = _signature_index;
46 if (_field_flags.is_injected()) {
47 return lookup_symbol(index);
48 }
49 return cp->symbol_at(index);
50 }
51
79 }
80
81 template<typename CON>
82 inline void Mapper<CON>::map_field_info(const FieldInfo& fi) {
83 _next_index++; // pre-increment
84 _consumer->accept_uint(fi.name_index());
85 _consumer->accept_uint(fi.signature_index());
86 _consumer->accept_uint(fi.offset());
87 _consumer->accept_uint(fi.access_flags().as_field_flags());
88 _consumer->accept_uint(fi.field_flags().as_uint());
89 if(fi.field_flags().has_any_optionals()) {
90 if (fi.field_flags().is_initialized()) {
91 _consumer->accept_uint(fi.initializer_index());
92 }
93 if (fi.field_flags().is_generic()) {
94 _consumer->accept_uint(fi.generic_signature_index());
95 }
96 if (fi.field_flags().is_contended()) {
97 _consumer->accept_uint(fi.contention_group());
98 }
99 } else {
100 assert(fi.initializer_index() == 0, "");
101 assert(fi.generic_signature_index() == 0, "");
102 assert(fi.contention_group() == 0, "");
103 }
104 }
105
106
107 inline FieldInfoReader::FieldInfoReader(const Array<u1>* fi)
108 : _r(fi->data(), fi->length()),
109 _next_index(0) { }
110
111 inline void FieldInfoReader::read_field_counts(int* java_fields, int* injected_fields) {
112 *java_fields = next_uint();
113 *injected_fields = next_uint();
114 }
115
116 inline void FieldInfoReader::read_name_and_signature(u2* name_index, u2* signature_index) {
117 *name_index = checked_cast<u2>(next_uint());
118 *signature_index = checked_cast<u2>(next_uint());
119 }
120
121 inline void FieldInfoReader::read_field_info(FieldInfo& fi) {
122 fi._index = _next_index++;
123 read_name_and_signature(&fi._name_index, &fi._signature_index);
124 fi._offset = next_uint();
125 fi._access_flags = AccessFlags(checked_cast<u2>(next_uint()));
126 fi._field_flags = FieldInfo::FieldFlags(next_uint());
127 if (fi._field_flags.is_initialized()) {
128 fi._initializer_index = checked_cast<u2>(next_uint());
129 } else {
130 fi._initializer_index = 0;
131 }
132 if (fi._field_flags.is_generic()) {
133 fi._generic_signature_index = checked_cast<u2>(next_uint());
134 } else {
135 fi._generic_signature_index = 0;
136 }
137 if (fi._field_flags.is_contended()) {
138 fi._contention_group = checked_cast<u2>(next_uint());
139 } else {
140 fi._contention_group = 0;
141 }
142 }
143
144 inline FieldInfoReader& FieldInfoReader::skip_field_info() {
145 _next_index++;
146 const int name_sig_af_off = 4; // four items
147 skip(name_sig_af_off);
148 FieldInfo::FieldFlags ff(next_uint());
149 if (ff.has_any_optionals()) {
150 const int init_gen_cont = (ff.is_initialized() +
151 ff.is_generic() +
152 ff.is_contended());
153 skip(init_gen_cont); // up to three items
154 }
155 return *this;
156 }
157
158 // Skip to the nth field. If the reader is freshly initialized to
159 // the zero index, this will call skip_field_info() n times.
160 inline FieldInfoReader& FieldInfoReader::skip_to_field_info(int n) {
161 assert(n >= _next_index, "already past that index");
162 const int count = n - _next_index;
163 for (int i = 0; i < count; i++) skip_field_info();
164 assert(_next_index == n, "");
165 return *this;
166 }
167
168 // for random access, if you know where to go up front:
169 inline FieldInfoReader& FieldInfoReader::set_position_and_next_index(int position, int next_index) {
170 _r.set_position(position);
171 _next_index = next_index;
172 return *this;
173 }
174
175 inline void FieldStatus::atomic_set_bits(u1& flags, u1 mask) {
176 AtomicAccess::fetch_then_or(&flags, mask);
177 }
178
179 inline void FieldStatus::atomic_clear_bits(u1& flags, u1 mask) {
180 AtomicAccess::fetch_then_and(&flags, (u1)(~mask));
181 }
182
183 inline void FieldStatus::update_flag(FieldStatusBitPosition pos, bool z) {
184 if (z) atomic_set_bits(_flags, flag_mask(pos));
185 else atomic_clear_bits(_flags, flag_mask(pos));
186 }
187
188 inline void FieldStatus::update_access_watched(bool z) { update_flag(_fs_access_watched, z); }
189 inline void FieldStatus::update_modification_watched(bool z) { update_flag(_fs_modification_watched, z); }
190 inline void FieldStatus::update_initialized_final_update(bool z) { update_flag(_initialized_final_update, z); }
191
192 #endif // SHARE_OOPS_FIELDINFO_INLINE_HPP
|
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_FIELDINFO_INLINE_HPP
26 #define SHARE_OOPS_FIELDINFO_INLINE_HPP
27
28 #include "oops/fieldInfo.hpp"
29
30 #include "memory/metadataFactory.hpp"
31 #include "oops/constantPool.hpp"
32 #include "oops/instanceKlass.hpp"
33 #include "oops/symbol.hpp"
34 #include "runtime/atomicAccess.hpp"
35 #include "utilities/checkedCast.hpp"
36
37 inline Symbol* FieldInfo::name(ConstantPool* cp) const {
38 int index = _name_index;
39 if (_field_flags.is_injected()) {
40 return lookup_symbol(index);
41 }
42 return cp->symbol_at(index);
43 }
44
45 inline Symbol* FieldInfo::signature(ConstantPool* cp) const {
46 int index = _signature_index;
47 if (_field_flags.is_injected()) {
48 return lookup_symbol(index);
49 }
50 return cp->symbol_at(index);
51 }
52
80 }
81
82 template<typename CON>
83 inline void Mapper<CON>::map_field_info(const FieldInfo& fi) {
84 _next_index++; // pre-increment
85 _consumer->accept_uint(fi.name_index());
86 _consumer->accept_uint(fi.signature_index());
87 _consumer->accept_uint(fi.offset());
88 _consumer->accept_uint(fi.access_flags().as_field_flags());
89 _consumer->accept_uint(fi.field_flags().as_uint());
90 if(fi.field_flags().has_any_optionals()) {
91 if (fi.field_flags().is_initialized()) {
92 _consumer->accept_uint(fi.initializer_index());
93 }
94 if (fi.field_flags().is_generic()) {
95 _consumer->accept_uint(fi.generic_signature_index());
96 }
97 if (fi.field_flags().is_contended()) {
98 _consumer->accept_uint(fi.contention_group());
99 }
100 if (fi.field_flags().is_flat()) {
101 assert(fi.layout_kind() != LayoutKind::UNKNOWN, "Must be set");
102 assert(fi.layout_kind() != LayoutKind::BUFFERED, "Sanity check");
103 _consumer->accept_uint((uint32_t)fi.layout_kind());
104 }
105 if (fi.field_flags().has_null_marker()) {
106 _consumer->accept_uint(fi.null_marker_offset());
107 }
108 } else {
109 assert(fi.initializer_index() == 0, "");
110 assert(fi.generic_signature_index() == 0, "");
111 assert(fi.contention_group() == 0, "");
112 assert(fi.null_marker_offset() == 0, "");
113 }
114 }
115
116
117 inline FieldInfoReader::FieldInfoReader(const Array<u1>* fi)
118 : _r(fi->data(), fi->length()),
119 _next_index(0) { }
120
121 inline void FieldInfoReader::read_field_counts(int* java_fields, int* injected_fields) {
122 *java_fields = next_uint();
123 *injected_fields = next_uint();
124 }
125
126 inline void FieldInfoReader::read_name_and_signature(u2* name_index, u2* signature_index) {
127 *name_index = checked_cast<u2>(next_uint());
128 *signature_index = checked_cast<u2>(next_uint());
129 }
130
131 inline void FieldInfoReader::read_field_info(FieldInfo& fi) {
132 fi._index = _next_index++;
133 read_name_and_signature(&fi._name_index, &fi._signature_index);
134 fi._offset = next_uint();
135 fi._access_flags = AccessFlags(checked_cast<u2>(next_uint()));
136 fi._field_flags = FieldInfo::FieldFlags(next_uint());
137 if (fi._field_flags.is_initialized()) {
138 fi._initializer_index = checked_cast<u2>(next_uint());
139 } else {
140 fi._initializer_index = 0;
141 }
142 if (fi._field_flags.is_generic()) {
143 fi._generic_signature_index = checked_cast<u2>(next_uint());
144 } else {
145 fi._generic_signature_index = 0;
146 }
147 if (fi._field_flags.is_contended()) {
148 fi._contention_group = checked_cast<u2>(next_uint());
149 } else {
150 fi._contention_group = 0;
151 }
152 if (fi._field_flags.is_flat()) {
153 fi._layout_kind = static_cast<LayoutKind>(next_uint());
154 }
155 if (fi._field_flags.has_null_marker()) {
156 fi._null_marker_offset = next_uint();
157 } else {
158 fi._null_marker_offset = 0;
159 }
160 }
161
162 inline FieldInfoReader& FieldInfoReader::skip_field_info() {
163 _next_index++;
164 const int name_sig_af_off = 4; // four items
165 skip(name_sig_af_off);
166 FieldInfo::FieldFlags ff(next_uint());
167 if (ff.has_any_optionals()) {
168 const int init_gen_cont = (ff.is_initialized() +
169 ff.is_generic() +
170 ff.is_contended() +
171 ff.is_flat() +
172 ff.has_null_marker());
173 skip(init_gen_cont); // up to three items
174 }
175 return *this;
176 }
177
178 // Skip to the nth field. If the reader is freshly initialized to
179 // the zero index, this will call skip_field_info() n times.
180 inline FieldInfoReader& FieldInfoReader::skip_to_field_info(int n) {
181 assert(n >= _next_index, "already past that index");
182 const int count = n - _next_index;
183 for (int i = 0; i < count; i++) skip_field_info();
184 assert(_next_index == n, "");
185 return *this;
186 }
187
188 // for random access, if you know where to go up front:
189 inline FieldInfoReader& FieldInfoReader::set_position_and_next_index(int position, int next_index) {
190 _r.set_position(position);
191 _next_index = next_index;
192 return *this;
193 }
194
195 inline void FieldStatus::atomic_set_bits(u1& flags, u1 mask) {
196 AtomicAccess::fetch_then_or(&flags, mask);
197 }
198
199 inline void FieldStatus::atomic_clear_bits(u1& flags, u1 mask) {
200 AtomicAccess::fetch_then_and(&flags, (u1)(~mask));
201 }
202
203 inline void FieldStatus::update_flag(FieldStatusBitPosition pos, bool z) {
204 if (z) atomic_set_bits(_flags, flag_mask(pos));
205 else atomic_clear_bits(_flags, flag_mask(pos));
206 }
207
208 inline void FieldStatus::update_access_watched(bool z) { update_flag(_fs_access_watched, z); }
209 inline void FieldStatus::update_modification_watched(bool z) { update_flag(_fs_modification_watched, z); }
210 inline void FieldStatus::update_strict_static_unset(bool z) { update_flag(_fs_strict_static_unset, z); }
211 inline void FieldStatus::update_strict_static_unread(bool z) { update_flag(_fs_strict_static_unread, z); }
212 inline void FieldStatus::update_initialized_final_update(bool z) { update_flag(_initialized_final_update, z); }
213
214 #endif // SHARE_OOPS_FIELDINFO_INLINE_HPP
|