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_HPP
26 #define SHARE_OOPS_FIELDINFO_HPP
27
28 #include "memory/allocation.hpp"
29 #include "oops/typeArrayOop.hpp"
30 #include "utilities/unsigned5.hpp"
31 #include "utilities/vmEnums.hpp"
32
33 static constexpr u4 flag_mask(int pos) {
34 return (u4)1 << pos;
35 }
36
37
38 // Helper class for access to the underlying Array<u1> used to
39 // store the compressed stream of FieldInfo
40 template<typename ARR, typename OFF>
41 struct ArrayHelper {
42 uint8_t operator()(ARR a, OFF i) const { return a->at(i); };
43 void operator()(ARR a, OFF i, uint8_t b) const { a->at_put(i,b); };
44 // So, an expression ArrayWriterHelper() acts like these lambdas:
45 // auto get = [&](ARR a, OFF i){ return a[i]; };
46 // auto set = [&](ARR a, OFF i, uint8_t x){ a[i] = x; };
47 };
48
49 // This class represents the field information contained in the fields
50 // array of an InstanceKlass. Currently it's laid on top an array of
51 // Java shorts but in the future it could simply be used as a real
52 // array type. FieldInfo generally shouldn't be used directly.
53 // Fields should be queried either through InstanceKlass or through
54 // the various FieldStreams.
55 class FieldInfo {
56 friend class fieldDescriptor;
57 friend class JavaFieldStream;
58 friend class ClassFileParser;
59 friend class FieldInfoStream;
60 friend class FieldStreamBase;
61 friend class FieldInfoReader;
62 friend class VMStructs;
63
64 public:
65
66 class FieldFlags {
67 friend class VMStructs;
68 friend class JVMCIVMStructs;
69
70 // The ordering of this enum is totally internal. More frequent
71 // flags should come earlier than less frequent ones, because
72 // earlier ones compress better.
73 enum FieldFlagBitPosition {
74 _ff_initialized, // has ConstantValue initializer attribute
75 _ff_injected, // internal field injected by the JVM
76 _ff_generic, // has a generic signature
77 _ff_stable, // trust as stable b/c declared as @Stable
78 _ff_contended, // is contended, may have contention-group
79 };
80
81 // Some but not all of the flag bits signal the presence of an
82 // additional 32-bit item in the field record.
83 static const u4 _optional_item_bit_mask =
84 flag_mask((int)_ff_initialized) |
85 flag_mask((int)_ff_generic) |
86 flag_mask((int)_ff_contended);
87
88 // boilerplate:
89 u4 _flags;
90
91 bool test_flag(FieldFlagBitPosition pos) const {
92 return (_flags & flag_mask(pos)) != 0;
93 }
94 void update_flag(FieldFlagBitPosition pos, bool z) {
95 if (z) _flags |= flag_mask(pos);
96 else _flags &= ~flag_mask(pos);
97 }
98
99 public:
100 FieldFlags(u4 flags) {
101 _flags = flags;
102 }
103 u4 as_uint() const { return _flags; }
104 bool has_any_optionals() const {
105 return (_flags & _optional_item_bit_mask) != 0;
106 }
107
108 bool is_initialized() const { return test_flag(_ff_initialized); }
109 bool is_injected() const { return test_flag(_ff_injected); }
110 bool is_generic() const { return test_flag(_ff_generic); }
111 bool is_stable() const { return test_flag(_ff_stable); }
112 bool is_contended() const { return test_flag(_ff_contended); }
113
114 void update_initialized(bool z) { update_flag(_ff_initialized, z); }
115 void update_injected(bool z) { update_flag(_ff_injected, z); }
116 void update_generic(bool z) { update_flag(_ff_generic, z); }
117 void update_stable(bool z) { update_flag(_ff_stable, z); }
118 void update_contended(bool z) { update_flag(_ff_contended, z); }
119 };
120
121 private:
122 // The following items are the unpacked bitwise information content
123 // of a field record. Per-field metadata extracted from the class
124 // file are stored logically as a group of these items. The
125 // classfile parser produces these records in a temporary array, and
126 // then compresses them into a FieldInfoStream.
127 //
128 u4 _index; // which field it is
129 u2 _name_index; // index in CP of name
130 u2 _signature_index; // index in CP of descriptor
131 u4 _offset; // offset in object layout
132 AccessFlags _access_flags; // access flags (JVM spec)
133 FieldFlags _field_flags; // VM defined flags (not JVM spec)
134 u2 _initializer_index; // index from ConstantValue attr (or 0)
135 u2 _generic_signature_index; // index from GenericSignature attr (or 0)
136 u2 _contention_group; // index from @Contended group item (or 0)
137
138 public:
139
140 FieldInfo() : _name_index(0),
141 _signature_index(0),
142 _offset(0),
143 _access_flags(AccessFlags(0)),
144 _field_flags(FieldFlags(0)),
145 _initializer_index(0),
146 _generic_signature_index(0),
147 _contention_group(0) { }
148
149 FieldInfo(AccessFlags access_flags, u2 name_index, u2 signature_index, u2 initval_index, FieldInfo::FieldFlags fflags) :
150 _name_index(name_index),
151 _signature_index(signature_index),
152 _offset(0),
153 _access_flags(access_flags),
154 _field_flags(fflags),
155 _initializer_index(initval_index),
156 _generic_signature_index(0),
157 _contention_group(0) {
158 if (initval_index != 0) {
159 _field_flags.update_initialized(true);
160 }
161 }
162
163 u4 index() const { return _index; }
164 void set_index(u4 index) { _index = index; }
165 u2 name_index() const { return _name_index; }
166 void set_name_index(u2 index) { _name_index = index; }
167 u2 signature_index() const { return _signature_index; }
168 void set_signature_index(u2 index) { _signature_index = index; }
169 u4 offset() const { return _offset; }
170 void set_offset(u4 offset) { _offset = offset; }
171 AccessFlags access_flags() const { return _access_flags; }
172 FieldFlags field_flags() const { return _field_flags; }
173 FieldFlags* field_flags_addr() { return &_field_flags; }
174 u2 initializer_index() const { return _initializer_index; }
175 void set_initializer_index(u2 index) { _initializer_index = index; }
176 u2 generic_signature_index() const { return _generic_signature_index; }
177 void set_generic_signature_index(u2 index) { _generic_signature_index = index; }
178 u2 contention_group() const { return _contention_group; }
179
180 bool is_contended() const {
181 return _field_flags.is_contended();
182 }
183
184 u2 contended_group() const {
185 assert(is_contended(), "");
186 return _contention_group;
187 }
188
189 void set_contended_group(u2 group) {
190 _field_flags.update_contended(true);
191 _contention_group = group;
192 }
193
|
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_HPP
26 #define SHARE_OOPS_FIELDINFO_HPP
27
28 #include "memory/allocation.hpp"
29 #include "oops/typeArrayOop.hpp"
30 #include "utilities/unsigned5.hpp"
31 #include "utilities/vmEnums.hpp"
32
33 static constexpr u4 flag_mask(int pos) {
34 return (u4)1 << pos;
35 }
36
37 enum LayoutKind {
38 REFERENCE = 0, // indirection to a heap allocated instance
39 PAYLOAD = 1, // layout used in heap allocated standalone instances, probably temporary for the transition
40 NON_ATOMIC_FLAT = 2, // flat, no guarantee of atomic updates, no null marker
41 ATOMIC_FLAT = 3, // flat, size compatible with atomic updates, alignment requirement is equal to the size
42 NULLABLE_ATOMIC_FLAT = 4, // flat, include a null marker, plus same properties as ATOMIC layout
43 UNKNOWN = 5 // used for uninitialized fields of type LayoutKind
44 };
45
46 // Helper class for access to the underlying Array<u1> used to
47 // store the compressed stream of FieldInfo
48 template<typename ARR, typename OFF>
49 struct ArrayHelper {
50 uint8_t operator()(ARR a, OFF i) const { return a->at(i); };
51 void operator()(ARR a, OFF i, uint8_t b) const { a->at_put(i,b); };
52 // So, an expression ArrayWriterHelper() acts like these lambdas:
53 // auto get = [&](ARR a, OFF i){ return a[i]; };
54 // auto set = [&](ARR a, OFF i, uint8_t x){ a[i] = x; };
55 };
56
57 // This class represents the field information contained in the fields
58 // array of an InstanceKlass. Currently it's laid on top an array of
59 // Java shorts but in the future it could simply be used as a real
60 // array type. FieldInfo generally shouldn't be used directly.
61 // Fields should be queried either through InstanceKlass or through
62 // the various FieldStreams.
63 class FieldInfo {
64 friend class fieldDescriptor;
65 friend class JavaFieldStream;
66 friend class ClassFileParser;
67 friend class FieldInfoStream;
68 friend class FieldStreamBase;
69 friend class FieldInfoReader;
70 friend class VMStructs;
71
72 public:
73
74 class FieldFlags {
75 friend class VMStructs;
76 friend class JVMCIVMStructs;
77 friend class FieldDesc;
78
79 // The ordering of this enum is totally internal. More frequent
80 // flags should come earlier than less frequent ones, because
81 // earlier ones compress better.
82 enum FieldFlagBitPosition {
83 _ff_null_free_inline_type, // field's type is an inline type and the field is null free
84 _ff_flat, // field is a flat field, optional section includes a layout kind
85 _ff_null_marker, // field has a null marker, optional section includes the null marker offset
86 _ff_initialized, // has ConstantValue initializer attribute
87 _ff_injected, // internal field injected by the JVM
88 _ff_generic, // has a generic signature
89 _ff_stable, // trust as stable b/c declared as @Stable
90 _ff_contended // is contended, may have contention-group
91 };
92
93 // Some but not all of the flag bits signal the presence of an
94 // additional 32-bit item in the field record.
95 static const u4 _optional_item_bit_mask =
96 flag_mask((int)_ff_initialized) |
97 flag_mask((int)_ff_generic) |
98 flag_mask((int)_ff_contended) |
99 flag_mask((int)_ff_flat) |
100 flag_mask((int)_ff_null_marker);
101
102 // boilerplate:
103 u4 _flags;
104
105 bool test_flag(FieldFlagBitPosition pos) const {
106 return (_flags & flag_mask(pos)) != 0;
107 }
108 void update_flag(FieldFlagBitPosition pos, bool z) {
109 if (z) _flags |= flag_mask(pos);
110 else _flags &= ~flag_mask(pos);
111 }
112
113 public:
114 FieldFlags(u4 flags) {
115 _flags = flags;
116 }
117 u4 as_uint() const { return _flags; }
118 bool has_any_optionals() const {
119 return (_flags & _optional_item_bit_mask) != 0;
120 }
121
122 bool is_initialized() const { return test_flag(_ff_initialized); }
123 bool is_null_free_inline_type() const { return test_flag(_ff_null_free_inline_type); }
124 bool is_flat() const { return test_flag(_ff_flat); }
125 bool is_injected() const { return test_flag(_ff_injected); }
126 bool is_generic() const { return test_flag(_ff_generic); }
127 bool is_stable() const { return test_flag(_ff_stable); }
128 bool is_contended() const { return test_flag(_ff_contended); }
129 bool has_null_marker() const { return test_flag(_ff_null_marker); }
130
131 void update_initialized(bool z) { update_flag(_ff_initialized, z); }
132 void update_null_free_inline_type(bool z) { update_flag(_ff_null_free_inline_type, z); }
133 void update_flat(bool z) { update_flag(_ff_flat, z); }
134 void update_injected(bool z) { update_flag(_ff_injected, z); }
135 void update_generic(bool z) { update_flag(_ff_generic, z); }
136 void update_stable(bool z) { update_flag(_ff_stable, z); }
137 void update_contended(bool z) { update_flag(_ff_contended, z); }
138 void update_null_marker(bool z) { update_flag(_ff_null_marker, z); }
139 };
140
141 private:
142 // The following items are the unpacked bitwise information content
143 // of a field record. Per-field metadata extracted from the class
144 // file are stored logically as a group of these items. The
145 // classfile parser produces these records in a temporary array, and
146 // then compresses them into a FieldInfoStream.
147 //
148 u4 _index; // which field it is
149 u2 _name_index; // index in CP of name
150 u2 _signature_index; // index in CP of descriptor
151 u4 _offset; // offset in object layout
152 AccessFlags _access_flags; // access flags (JVM spec)
153 FieldFlags _field_flags; // VM defined flags (not JVM spec)
154 LayoutKind _layout_kind; // LayoutKind if the field is flat
155 u4 _null_marker_offset; // null marker offset for this field in the object layout
156 u2 _initializer_index; // index from ConstantValue attr (or 0)
157 u2 _generic_signature_index; // index from GenericSignature attr (or 0)
158 u2 _contention_group; // index from @Contended group item (or 0)
159
160 public:
161
162 FieldInfo() : _name_index(0),
163 _signature_index(0),
164 _offset(0),
165 _access_flags(AccessFlags(0)),
166 _field_flags(FieldFlags(0)),
167 _layout_kind(LayoutKind::UNKNOWN),
168 _null_marker_offset(0),
169 _initializer_index(0),
170 _generic_signature_index(0),
171 _contention_group(0) { }
172
173 FieldInfo(AccessFlags access_flags, u2 name_index, u2 signature_index, u2 initval_index, FieldInfo::FieldFlags fflags) :
174 _name_index(name_index),
175 _signature_index(signature_index),
176 _offset(0),
177 _access_flags(access_flags),
178 _field_flags(fflags),
179 _layout_kind(LayoutKind::UNKNOWN),
180 _null_marker_offset(0),
181 _initializer_index(initval_index),
182 _generic_signature_index(0),
183 _contention_group(0) {
184 if (initval_index != 0) {
185 _field_flags.update_initialized(true);
186 }
187 }
188
189 u4 index() const { return _index; }
190 void set_index(u4 index) { _index = index; }
191 u2 name_index() const { return _name_index; }
192 void set_name_index(u2 index) { _name_index = index; }
193 u2 signature_index() const { return _signature_index; }
194 void set_signature_index(u2 index) { _signature_index = index; }
195 u4 offset() const { return _offset; }
196 void set_offset(u4 offset) { _offset = offset; }
197 AccessFlags access_flags() const { return _access_flags; }
198 FieldFlags field_flags() const { return _field_flags; }
199 FieldFlags* field_flags_addr() { return &_field_flags; }
200 LayoutKind layout_kind() const { return _layout_kind; }
201 void set_layout_kind(LayoutKind lk) {
202 assert(_field_flags.is_flat(), "Must be");
203 _layout_kind = lk;
204 }
205 u4 null_marker_offset() const { return _null_marker_offset; }
206 void set_null_marker_offset(u4 offset) {
207 _field_flags.update_null_marker(true);
208 _null_marker_offset = offset;
209 }
210 u2 initializer_index() const { return _initializer_index; }
211 void set_initializer_index(u2 index) { _initializer_index = index; }
212 u2 generic_signature_index() const { return _generic_signature_index; }
213 void set_generic_signature_index(u2 index) { _generic_signature_index = index; }
214 u2 contention_group() const { return _contention_group; }
215
216 bool is_contended() const {
217 return _field_flags.is_contended();
218 }
219
220 u2 contended_group() const {
221 assert(is_contended(), "");
222 return _contention_group;
223 }
224
225 void set_contended_group(u2 group) {
226 _field_flags.update_contended(true);
227 _contention_group = group;
228 }
229
|