1 /*
  2  * Copyright (c) 2020, 2025, 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   int _oop_count;
148   static const int INITIAL_LIST_SIZE = 16;
149 
150  public:
151   FieldGroup(int contended_group = -1);
152 
153   FieldGroup* next() const { return _next; }
154   void set_next(FieldGroup* next) { _next = next; }
155   GrowableArray<LayoutRawBlock*>* small_primitive_fields() const { return _small_primitive_fields; }
156   GrowableArray<LayoutRawBlock*>* big_primitive_fields() const { return _big_primitive_fields; }
157   GrowableArray<LayoutRawBlock*>* oop_fields() const { return _oop_fields; }
158   int contended_group() const { return _contended_group; }
159   int oop_count() const { return _oop_count; }
160 
161   void add_primitive_field(int idx, BasicType type);
162   void add_oop_field(int idx);
163   void add_flat_field(int idx, InlineKlass* vk, LayoutKind lk, int size, int alignment);
164   void add_block(LayoutRawBlock** list, LayoutRawBlock* block);
165   void sort_by_size();
166  private:
167   void add_to_small_primitive_list(LayoutRawBlock* block);
168   void add_to_big_primitive_list(LayoutRawBlock* block);
169 };
170 
171 // The FieldLayout class represents a set of fields organized
172 // in a layout.
173 // An instance of FieldLayout can either represent the layout
174 // of non-static fields (used in an instance object) or the
175 // layout of static fields (to be included in the class mirror).
176 //
177 // _block is a pointer to a list of LayoutRawBlock ordered by increasing
178 // offsets.
179 // _start points to the LayoutRawBlock with the first offset that can
180 // be used to allocate fields of the current class
181 // _last points to the last LayoutRawBlock of the list. In order to
182 // simplify the code, the LayoutRawBlock list always ends with an
183 // EMPTY block (the kind of LayoutRawBlock from which space is taken
184 // to allocate fields) with a size big enough to satisfy all
185 // field allocations.
186 //
187 class FieldLayout : public ResourceObj {
188  private:
189   GrowableArray<FieldInfo>* _field_info;
190   Array<InlineLayoutInfo>* _inline_layout_info_array;
191   ConstantPool* _cp;
192   LayoutRawBlock* _blocks;  // the layout being computed
193   LayoutRawBlock* _start;   // points to the first block where a field can be inserted
194   LayoutRawBlock* _last;    // points to the last block of the layout (big empty block)
195   int _super_first_field_offset;
196   int _super_alignment;
197   int _super_min_align_required;
198   int _null_reset_value_offset;    // offset of the reset value in class mirror, only for static layout of inline classes
199   bool _super_has_fields;
200   bool _has_inherited_fields;
201 
202  public:
203   FieldLayout(GrowableArray<FieldInfo>* field_info, Array<InlineLayoutInfo>* inline_layout_info_array, ConstantPool* cp);
204   void initialize_static_layout();
205   void initialize_instance_layout(const InstanceKlass* ik, bool& super_ends_with_oop);
206 
207   LayoutRawBlock* first_empty_block() {
208     LayoutRawBlock* block = _start;
209     while (block->block_kind() != LayoutRawBlock::EMPTY) {
210       block = block->next_block();
211     }
212     return block;
213   }
214 
215   LayoutRawBlock* blocks() const { return _blocks; }
216 
217   LayoutRawBlock* start() const { return _start; }
218   void set_start(LayoutRawBlock* start) { _start = start; }
219   LayoutRawBlock* last_block() const  { return _last; }
220   int super_first_field_offset() const { return _super_first_field_offset; }
221   int super_alignment() const { return _super_alignment; }
222   int super_min_align_required() const { return _super_min_align_required; }
223   int null_reset_value_offset() const {
224     assert(_null_reset_value_offset != -1, "Must have been set");
225     return _null_reset_value_offset;
226   }
227   bool super_has_fields() const { return _super_has_fields; }
228   bool has_inherited_fields() const { return _has_inherited_fields; }
229 
230   LayoutRawBlock* first_field_block();
231   void add(GrowableArray<LayoutRawBlock*>* list, LayoutRawBlock* start = nullptr);
232   void add_field_at_offset(LayoutRawBlock* blocks, int offset, LayoutRawBlock* start = nullptr);
233   void add_contiguously(GrowableArray<LayoutRawBlock*>* list, LayoutRawBlock* start = nullptr);
234   LayoutRawBlock* insert_field_block(LayoutRawBlock* slot, LayoutRawBlock* block);
235   void reconstruct_layout(const InstanceKlass* ik, bool& has_instance_fields, bool& ends_with_oop);
236   void fill_holes(const InstanceKlass* ik);
237   LayoutRawBlock* insert(LayoutRawBlock* slot, LayoutRawBlock* block);
238   void remove(LayoutRawBlock* block);
239   void shift_fields(int shift);
240   LayoutRawBlock* find_null_marker();
241   void remove_null_marker();
242   void print(outputStream* output, bool is_static, const InstanceKlass* super, Array<InlineLayoutInfo>* inline_fields);
243 };
244 
245 
246 // FieldLayoutBuilder is the main entry point for layout computation.
247 // This class has two methods to generate layout: one for identity classes
248 // and one for inline classes. The rational for having two methods
249 // is that each kind of classes has a different set goals regarding
250 // its layout, so instead of mixing two layout strategies into a
251 // single method, each kind has its own method (see comments below
252 // for more details about the allocation strategies).
253 //
254 // Computing the layout of a class always goes through 4 steps:
255 //   1 - Prologue: preparation of data structure and gathering of
256 //       layout information inherited from super classes
257 //   2 - Field sorting: fields are sorted according to their
258 //       kind (oop, primitive, inline class) and their contention
259 //       annotation (if any)
260 //   3 - Layout is computed from the set of lists generated during
261 //       step 2
262 //   4 - Epilogue: oopmaps are generated, layout information is
263 //       prepared so other VM components can use it (instance size,
264 //       static field size, non-static field size, etc.)
265 //
266 //  Steps 1 and 4 are common to all layout computations. Step 2 and 3
267 //  differ for inline classes and identity classes.
268 //
269 class FieldLayoutBuilder : public ResourceObj {
270 
271  private:
272   const Symbol* _classname;
273   ClassLoaderData* _loader_data;
274   const InstanceKlass* _super_klass;
275   ConstantPool* _constant_pool;
276   GrowableArray<FieldInfo>* _field_info;
277   FieldLayoutInfo* _info;
278   Array<InlineLayoutInfo>* _inline_layout_info_array;
279   FieldGroup* _root_group;
280   GrowableArray<FieldGroup*> _contended_groups;
281   FieldGroup* _static_fields;
282   FieldLayout* _layout;
283   FieldLayout* _static_layout;
284   int _nonstatic_oopmap_count;
285   int _payload_alignment;
286   int _payload_offset;
287   int _null_marker_offset; // if any, -1 means no internal null marker
288   int _payload_size_in_bytes;
289   int _non_atomic_layout_size_in_bytes;
290   int _non_atomic_layout_alignment;
291   int _atomic_layout_size_in_bytes;
292   int _nullable_layout_size_in_bytes;
293   int _fields_size_sum;
294   int _declared_non_static_fields_count;
295   bool _has_non_naturally_atomic_fields;
296   bool _is_naturally_atomic;
297   bool _must_be_atomic;
298   bool _has_nonstatic_fields;
299   bool _has_inline_type_fields;
300   bool _is_contended;
301   bool _super_ends_with_oop;
302   bool _is_inline_type;
303   bool _is_abstract_value;
304   bool _has_flattening_information;
305   bool _is_empty_inline_class;
306 
307   FieldGroup* get_or_create_contended_group(int g);
308 
309  public:
310   FieldLayoutBuilder(const Symbol* classname, ClassLoaderData* loader_data, const InstanceKlass* super_klass, ConstantPool* constant_pool,
311                      GrowableArray<FieldInfo>* field_info, bool is_contended, bool is_inline_type, bool is_abstract_value,
312                      bool must_be_atomic, FieldLayoutInfo* info, Array<InlineLayoutInfo>* inline_layout_info_array);
313 
314   int payload_offset() const               { assert(_payload_offset != -1, "Uninitialized"); return _payload_offset; }
315   int  payload_layout_size_in_bytes() const    { return _payload_size_in_bytes; }
316   int  payload_layout_alignment() const        { assert(_payload_alignment != -1, "Uninitialized"); return _payload_alignment; }
317   bool has_non_atomic_flat_layout() const      { return _non_atomic_layout_size_in_bytes != -1; }
318   int  non_atomic_layout_size_in_bytes() const { return _non_atomic_layout_size_in_bytes; }
319   int  non_atomic_layout_alignment() const     { return _non_atomic_layout_alignment; }
320   bool has_atomic_layout() const               { return _atomic_layout_size_in_bytes != -1; }
321   int  atomic_layout_size_in_bytes() const     { return _atomic_layout_size_in_bytes; }
322   bool has_nullable_atomic_layout() const      { return _nullable_layout_size_in_bytes != -1; }
323   int  nullable_layout_size_in_bytes() const   { return _nullable_layout_size_in_bytes; }
324   int  null_marker_offset() const              { return _null_marker_offset; }
325   bool is_empty_inline_class() const           { return _is_empty_inline_class; }
326 
327   void build_layout();
328   void compute_regular_layout();
329   void compute_inline_class_layout();
330   void insert_contended_padding(LayoutRawBlock* slot);
331 
332  protected:
333   void prologue();
334   void epilogue();
335   void regular_field_sorting();
336   void inline_class_field_sorting();
337   void add_flat_field_oopmap(OopMapBlocksBuilder* nonstatic_oop_map, InlineKlass* vk, int offset);
338   void register_embedded_oops_from_list(OopMapBlocksBuilder* nonstatic_oop_maps, GrowableArray<LayoutRawBlock*>* list);
339   void register_embedded_oops(OopMapBlocksBuilder* nonstatic_oop_maps, FieldGroup* group);
340 };
341 
342 #endif // SHARE_CLASSFILE_FIELDLAYOUTBUILDER_HPP