1 /*
2 * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
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_CLASSFILE_FIELDLAYOUTBUILDER_HPP
26 #define SHARE_CLASSFILE_FIELDLAYOUTBUILDER_HPP
27
28 #include "classfile/classFileParser.hpp"
29 #include "classfile/classLoaderData.hpp"
30 #include "memory/allocation.hpp"
31 #include "oops/fieldStreams.hpp"
32 #include "oops/inlineKlass.hpp"
33 #include "oops/instanceKlass.hpp"
34 #include "utilities/growableArray.hpp"
35
36 // Classes below are used to compute the field layout of classes.
37
38 // A LayoutRawBlock describes an element of a layout.
39 // Each field is represented by a LayoutRawBlock.
40 // LayoutRawBlocks can also represent elements injected by the JVM:
41 // padding, empty blocks, inherited fields, etc.
42 // All LayoutRawBlocks must have a size and an alignment. The size is the
43 // exact size of the field expressed in bytes. The alignment is
44 // the alignment constraint of the field (1 for byte, 2 for short,
45 // 4 for int, 8 for long, etc.)
46 //
47 // LayoutRawBlock are designed to be used in two data structures:
48 // - a linked list in a layout (using _next_block, _prev_block)
49 // - a GrowableArray in field group (the growable array contains pointers to LayoutRawBlocks)
50 //
51 // next/prev pointers are included in the LayoutRawBlock class to narrow
52 // the number of allocation required during the computation of a layout.
53 //
54
55 #define MAX_ATOMIC_OP_SIZE sizeof(uint64_t)
56
57 class LayoutRawBlock : public ResourceObj {
58 public:
59 // Some code relies on the order of values below.
60 enum Kind {
61 EMPTY, // empty slot, space is taken from this to allocate fields
62 RESERVED, // reserved for JVM usage (for instance object header)
63 PADDING, // padding (because of alignment constraints or @Contended)
64 REGULAR, // primitive or oop field (including not flat inline type fields)
65 FLAT, // flat field
66 INHERITED, // field(s) inherited from super classes
67 NULL_MARKER // stores the null marker for a flat field
68 };
69
70 private:
71 LayoutRawBlock* _next_block;
72 LayoutRawBlock* _prev_block;
73 InlineKlass* _inline_klass;
74 Kind _block_kind;
75 LayoutKind _layout_kind;
76 int _offset;
77 int _alignment;
78 int _size;
79 int _field_index;
80
81 public:
82 LayoutRawBlock(Kind kind, int size);
83
84 LayoutRawBlock(int index, Kind kind, int size, int alignment);
85 LayoutRawBlock* next_block() const { return _next_block; }
86 void set_next_block(LayoutRawBlock* next) { _next_block = next; }
87 LayoutRawBlock* prev_block() const { return _prev_block; }
88 void set_prev_block(LayoutRawBlock* prev) { _prev_block = prev; }
89 Kind block_kind() const { return _block_kind; }
90 void set_block_kind(LayoutRawBlock::Kind kind) { _block_kind = kind; } // Dangerous operation, is only used by remove_null_marker();
91 int offset() const {
92 assert(_offset >= 0, "Must be initialized");
93 return _offset;
94 }
95 void set_offset(int offset) { _offset = offset; }
96 int alignment() const { return _alignment; }
97 int size() const { return _size; }
98 void set_size(int size) { _size = size; }
99 int field_index() const {
100 assert(_field_index != -1, "Must be initialized");
101 return _field_index;
102 }
103 void set_field_index(int field_index) {
104 assert(_field_index == -1, "Must not be initialized");
105 _field_index = field_index;
106 }
107 InlineKlass* inline_klass() const {
108 assert(_inline_klass != nullptr, "Must be initialized");
109 return _inline_klass;
110 }
111 void set_inline_klass(InlineKlass* inline_klass) { _inline_klass = inline_klass; }
112
113 LayoutKind layout_kind() const { return _layout_kind; }
114 void set_layout_kind(LayoutKind kind) { _layout_kind = kind; }
115
116 bool fit(int size, int alignment);
117
118 static int compare_offset(LayoutRawBlock** x, LayoutRawBlock** y) { return (*x)->offset() - (*y)->offset(); }
119 // compare_size_inverted() returns the opposite of a regular compare method in order to
120 // sort fields in decreasing order.
121 // Note: with line types, the comparison should include alignment constraint if sizes are equals
122 static int compare_size_inverted(LayoutRawBlock** x, LayoutRawBlock** y) {
123 int diff = (*y)->size() - (*x)->size();
124 // qsort() may reverse the order of fields with the same size.
125 // The extension is to ensure stable sort.
126 if (diff == 0) {
127 diff = (*x)->field_index() - (*y)->field_index();
128 }
129 return diff;
130 }
131 };
132
133 // A Field group represents a set of fields that have to be allocated together,
134 // this is the way the @Contended annotation is supported.
135 // Inside a FieldGroup, fields are sorted based on their kind: primitive,
136 // oop, or flat.
137 //
138 class FieldGroup : public ResourceObj {
139
140 private:
141 FieldGroup* _next;
142
143 GrowableArray<LayoutRawBlock*>* _small_primitive_fields;
144 GrowableArray<LayoutRawBlock*>* _big_primitive_fields;
145 GrowableArray<LayoutRawBlock*>* _oop_fields;
146 int _contended_group;
147 static const int INITIAL_LIST_SIZE = 16;
148
149 public:
150 FieldGroup(int contended_group = -1);
151
152 FieldGroup* next() const { return _next; }
153 void set_next(FieldGroup* next) { _next = next; }
154 GrowableArray<LayoutRawBlock*>* small_primitive_fields() const { return _small_primitive_fields; }
155 GrowableArray<LayoutRawBlock*>* big_primitive_fields() const { return _big_primitive_fields; }
156 GrowableArray<LayoutRawBlock*>* oop_fields() const { return _oop_fields; }
157 int contended_group() const { return _contended_group; }
158
159 void add_primitive_field(int idx, BasicType type);
160 void add_oop_field(int idx);
161 void add_flat_field(int idx, InlineKlass* vk, LayoutKind lk);
162 void add_block(LayoutRawBlock** list, LayoutRawBlock* block);
163 void sort_by_size();
164 private:
165 void add_to_small_primitive_list(LayoutRawBlock* block);
166 void add_to_big_primitive_list(LayoutRawBlock* block);
167 };
168
169 // The FieldLayout class represents a set of fields organized
170 // in a layout.
171 // An instance of FieldLayout can either represent the layout
172 // of non-static fields (used in an instance object) or the
173 // layout of static fields (to be included in the class mirror).
174 //
175 // _block is a pointer to a list of LayoutRawBlock ordered by increasing
176 // offsets.
177 // _start points to the LayoutRawBlock with the first offset that can
178 // be used to allocate fields of the current class
179 // _last points to the last LayoutRawBlock of the list. In order to
180 // simplify the code, the LayoutRawBlock list always ends with an
181 // EMPTY block (the kind of LayoutRawBlock from which space is taken
182 // to allocate fields) with a size big enough to satisfy all
183 // field allocations.
184 //
185 class FieldLayout : public ResourceObj {
186 private:
187 GrowableArray<FieldInfo>* _field_info;
188 Array<InlineLayoutInfo>* _inline_layout_info_array;
189 ConstantPool* _cp;
190 LayoutRawBlock* _blocks; // the layout being computed
191 LayoutRawBlock* _start; // points to the first block where a field can be inserted
192 LayoutRawBlock* _last; // points to the last block of the layout (big empty block)
193 int _super_first_field_offset;
194 int _super_alignment;
195 int _super_min_align_required;
196 int _null_reset_value_offset; // offset of the reset value in class mirror, only for static layout of inline classes
197 int _acmp_maps_offset;
198 bool _super_has_nonstatic_fields;
199 bool _has_inherited_fields;
200
201 public:
202 FieldLayout(GrowableArray<FieldInfo>* field_info, Array<InlineLayoutInfo>* inline_layout_info_array, ConstantPool* cp);
203 void initialize_static_layout();
204 void initialize_instance_layout(const InstanceKlass* ik, bool& super_ends_with_oop);
205
206 LayoutRawBlock* first_empty_block() {
207 LayoutRawBlock* block = _start;
208 while (block->block_kind() != LayoutRawBlock::EMPTY) {
209 block = block->next_block();
210 }
211 return block;
212 }
213
214 LayoutRawBlock* blocks() const { return _blocks; }
215
216 LayoutRawBlock* start() const { return _start; }
217 void set_start(LayoutRawBlock* start) { _start = start; }
218 LayoutRawBlock* last_block() const { return _last; }
219 int super_first_field_offset() const { return _super_first_field_offset; }
220 int super_alignment() const { return _super_alignment; }
221 int super_min_align_required() const { return _super_min_align_required; }
222 int null_reset_value_offset() const {
223 assert(_null_reset_value_offset != -1, "Must have been set");
224 return _null_reset_value_offset;
225 }
226 int acmp_maps_offset() const {
227 assert(_acmp_maps_offset != -1, "Must have been set");
228 return _acmp_maps_offset;
229 }
230 bool super_has_nonstatic_fields() const { return _super_has_nonstatic_fields; }
231 bool has_inherited_fields() const { return _has_inherited_fields; }
232
233 LayoutRawBlock* first_field_block();
234 void add(GrowableArray<LayoutRawBlock*>* list, LayoutRawBlock* start = nullptr);
235 void add_field_at_offset(LayoutRawBlock* blocks, int offset, LayoutRawBlock* start = nullptr);
236 void add_contiguously(GrowableArray<LayoutRawBlock*>* list, LayoutRawBlock* start = nullptr);
237 LayoutRawBlock* insert_field_block(LayoutRawBlock* slot, LayoutRawBlock* block);
238 void reconstruct_layout(const InstanceKlass* ik, bool& has_nonstatic_fields, bool& ends_with_oop);
239 void fill_holes(const InstanceKlass* ik);
240 LayoutRawBlock* insert(LayoutRawBlock* slot, LayoutRawBlock* block);
241 void remove(LayoutRawBlock* block);
242 void shift_fields(int shift);
243 LayoutRawBlock* find_null_marker();
244 void remove_null_marker();
245 void print(outputStream* output, bool is_static, const InstanceKlass* super, Array<InlineLayoutInfo>* inline_fields, bool dummy_field_is_reused_as_null_marker);
246 };
247
248
249 // FieldLayoutBuilder is the main entry point for layout computation.
250 // This class has two methods to generate layout: one for identity classes
251 // and one for inline classes. The rational for having two methods
252 // is that each kind of classes has a different set goals regarding
253 // its layout, so instead of mixing two layout strategies into a
254 // single method, each kind has its own method (see comments below
255 // for more details about the allocation strategies).
256 //
257 // Computing the layout of a class always goes through 4 steps:
258 // 1 - Prologue: preparation of data structure and gathering of
259 // layout information inherited from super classes
260 // 2 - Field sorting: fields are sorted according to their
261 // kind (oop, primitive, inline class) and their contention
262 // annotation (if any)
263 // 3 - Layout is computed from the set of lists generated during
264 // step 2
265 // 4 - Epilogue: oopmaps are generated, layout information is
266 // prepared so other VM components can use it (instance size,
267 // static field size, non-static field size, etc.)
268 //
269 // Steps 1 and 4 are common to all layout computations. Step 2 and 3
270 // differ for inline classes and identity classes.
271 //
272 class FieldLayoutBuilder : public ResourceObj {
273
274 private:
275 const Symbol* _classname;
276 ClassLoaderData* _loader_data;
277 const InstanceKlass* _super_klass;
278 ConstantPool* _constant_pool;
279 GrowableArray<FieldInfo>* _field_info;
280 FieldLayoutInfo* _info;
281 Array<InlineLayoutInfo>* _inline_layout_info_array;
282 FieldGroup* _root_group;
283 GrowableArray<FieldGroup*> _contended_groups;
284 FieldGroup* _static_fields;
285 FieldLayout* _layout;
286 FieldLayout* _static_layout;
287 GrowableArray<AcmpMapSegment>* _nonoop_acmp_map;
288 GrowableArray<int>* _oop_acmp_map;
289 int _nonstatic_oopmap_count;
290 int _payload_alignment;
291 int _payload_offset;
292 int _null_marker_offset; // if any, -1 means no internal null marker
293 int _payload_size_in_bytes;
294 int _null_free_non_atomic_layout_size_in_bytes;
295 int _null_free_non_atomic_layout_alignment;
296 int _null_free_atomic_layout_size_in_bytes;
297 int _nullable_atomic_layout_size_in_bytes;
298 int _nullable_non_atomic_layout_size_in_bytes;
299 int _fields_size_sum;
300 int _declared_nonstatic_fields_count;
301 bool _has_non_naturally_atomic_fields;
302 bool _is_naturally_atomic;
303 bool _must_be_atomic;
304 bool _has_nonstatic_fields;
305 bool _has_inlineable_fields;
306 bool _has_inlined_fields;
307 bool _is_contended;
308 bool _super_ends_with_oop;
309 bool _is_inline_type;
310 bool _is_abstract_value;
311 bool _is_empty_inline_class;
312
313 FieldGroup* get_or_create_contended_group(int g);
314
315 public:
316 FieldLayoutBuilder(const Symbol* classname, ClassLoaderData* loader_data, const InstanceKlass* super_klass, ConstantPool* constant_pool,
317 GrowableArray<FieldInfo>* field_info, bool is_contended, bool is_inline_type, bool is_abstract_value,
318 bool must_be_atomic, FieldLayoutInfo* info, Array<InlineLayoutInfo>* inline_layout_info_array);
319
320 int payload_offset() const { assert(_payload_offset != -1, "Uninitialized"); return _payload_offset; }
321 int payload_layout_size_in_bytes() const { return _payload_size_in_bytes; }
322 int payload_layout_alignment() const { assert(_payload_alignment != -1, "Uninitialized"); return _payload_alignment; }
323 bool has_null_free_non_atomic_flat_layout() const { return _null_free_non_atomic_layout_size_in_bytes != -1; }
324 int null_free_non_atomic_layout_size_in_bytes() const { return _null_free_non_atomic_layout_size_in_bytes; }
325 int null_free_non_atomic_layout_alignment() const { return _null_free_non_atomic_layout_alignment; }
326 bool has_null_free_atomic_layout() const { return _null_free_atomic_layout_size_in_bytes != -1; }
327 int null_free_atomic_layout_size_in_bytes() const { return _null_free_atomic_layout_size_in_bytes; }
328 bool has_nullable_atomic_layout() const { return _nullable_atomic_layout_size_in_bytes != -1; }
329 int nullable_atomic_layout_size_in_bytes() const { return _nullable_atomic_layout_size_in_bytes; }
330 bool has_nullable_non_atomic_layout() const { return _nullable_non_atomic_layout_size_in_bytes != -1; }
331 int nullable_non_atomic_layout_size_in_bytes() const { return _nullable_non_atomic_layout_size_in_bytes; }
332 int null_marker_offset() const { return _null_marker_offset; }
333 bool is_empty_inline_class() const { return _is_empty_inline_class; }
334
335 void build_layout();
336 void compute_regular_layout();
337 void compute_inline_class_layout();
338 LayoutRawBlock* insert_contended_padding(LayoutRawBlock* slot);
339
340 protected:
341 void prologue();
342 void epilogue();
343 void regular_field_sorting();
344 void inline_class_field_sorting();
345 void add_flat_field_oopmap(OopMapBlocksBuilder* nonstatic_oop_map, InlineKlass* vk, int offset);
346 void register_embedded_oops_from_list(OopMapBlocksBuilder* nonstatic_oop_maps, GrowableArray<LayoutRawBlock*>* list);
347 void register_embedded_oops(OopMapBlocksBuilder* nonstatic_oop_maps, FieldGroup* group);
348 void generate_acmp_maps();
349 };
350
351 #endif // SHARE_CLASSFILE_FIELDLAYOUTBUILDER_HPP