1 /* 2 * Copyright (c) 2011, 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_OOPS_FIELDINFO_HPP 26 #define SHARE_OOPS_FIELDINFO_HPP 27 28 #include "memory/allocation.hpp" 29 #include "oops/typeArrayOop.hpp" 30 #include "utilities/accessFlags.hpp" 31 #include "utilities/unsigned5.hpp" 32 #include "utilities/vmEnums.hpp" 33 34 static constexpr u4 flag_mask(int pos) { 35 return (u4)1 << pos; 36 } 37 38 39 // Helper class for access to the underlying Array<u1> used to 40 // store the compressed stream of FieldInfo 41 template<typename ARR, typename OFF> 42 struct ArrayHelper { 43 uint8_t operator()(ARR a, OFF i) const { return a->at(i); }; 44 void operator()(ARR a, OFF i, uint8_t b) const { a->at_put(i,b); }; 45 // So, an expression ArrayWriterHelper() acts like these lambdas: 46 // auto get = [&](ARR a, OFF i){ return a[i]; }; 47 // auto set = [&](ARR a, OFF i, uint8_t x){ a[i] = x; }; 48 }; 49 50 // This class represents the field information contained in the fields 51 // array of an InstanceKlass. Currently it's laid on top an array of 52 // Java shorts but in the future it could simply be used as a real 53 // array type. FieldInfo generally shouldn't be used directly. 54 // Fields should be queried either through InstanceKlass or through 55 // the various FieldStreams. 56 class FieldInfo { 57 friend class fieldDescriptor; 58 friend class JavaFieldStream; 59 friend class ClassFileParser; 60 friend class FieldInfoStream; 61 friend class FieldStreamBase; 62 friend class FieldInfoReader; 63 friend class VMStructs; 64 65 public: 66 67 class FieldFlags { 68 friend class VMStructs; 69 friend class JVMCIVMStructs; 70 71 // The ordering of this enum is totally internal. More frequent 72 // flags should come earlier than less frequent ones, because 73 // earlier ones compress better. 74 enum FieldFlagBitPosition { 75 _ff_initialized, // has ConstantValue initializer attribute 76 _ff_injected, // internal field injected by the JVM 77 _ff_generic, // has a generic signature 78 _ff_stable, // trust as stable b/c declared as @Stable 79 _ff_contended, // is contended, may have contention-group 80 }; 81 82 // Some but not all of the flag bits signal the presence of an 83 // additional 32-bit item in the field record. 84 static const u4 _optional_item_bit_mask = 85 flag_mask((int)_ff_initialized) | 86 flag_mask((int)_ff_generic) | 87 flag_mask((int)_ff_contended); 88 89 // boilerplate: 90 u4 _flags; 91 92 bool test_flag(FieldFlagBitPosition pos) const { 93 return (_flags & flag_mask(pos)) != 0; 94 } 95 void update_flag(FieldFlagBitPosition pos, bool z) { 96 if (z) _flags |= flag_mask(pos); 97 else _flags &= ~flag_mask(pos); 98 } 99 100 public: 101 FieldFlags(u4 flags) { 102 _flags = flags; 103 } 104 u4 as_uint() const { return _flags; } 105 bool has_any_optionals() const { 106 return (_flags & _optional_item_bit_mask) != 0; 107 } 108 109 bool is_initialized() const { return test_flag(_ff_initialized); } 110 bool is_injected() const { return test_flag(_ff_injected); } 111 bool is_generic() const { return test_flag(_ff_generic); } 112 bool is_stable() const { return test_flag(_ff_stable); } 113 bool is_contended() const { return test_flag(_ff_contended); } 114 115 void update_initialized(bool z) { update_flag(_ff_initialized, z); } 116 void update_injected(bool z) { update_flag(_ff_injected, z); } 117 void update_generic(bool z) { update_flag(_ff_generic, z); } 118 void update_stable(bool z) { update_flag(_ff_stable, z); } 119 void update_contended(bool z) { update_flag(_ff_contended, z); } 120 }; 121 122 private: 123 // The following items are the unpacked bitwise information content 124 // of a field record. Per-field metadata extracted from the class 125 // file are stored logically as a group of these items. The 126 // classfile parser produces these records in a temporary array, and 127 // then compresses them into a FieldInfoStream. 128 // 129 u4 _index; // which field it is 130 u2 _name_index; // index in CP of name 131 u2 _signature_index; // index in CP of descriptor 132 u4 _offset; // offset in object layout 133 AccessFlags _access_flags; // access flags (JVM spec) 134 FieldFlags _field_flags; // VM defined flags (not JVM spec) 135 u2 _initializer_index; // index from ConstantValue attr (or 0) 136 u2 _generic_signature_index; // index from GenericSignature attr (or 0) 137 u2 _contention_group; // index from @Contended group item (or 0) 138 139 public: 140 141 FieldInfo() : _index(0), 142 _name_index(0), 143 _signature_index(0), 144 _offset(0), 145 _access_flags(AccessFlags(0)), 146 _field_flags(FieldFlags(0)), 147 _initializer_index(0), 148 _generic_signature_index(0), 149 _contention_group(0) { } 150 151 FieldInfo(AccessFlags access_flags, u2 name_index, u2 signature_index, u2 initval_index, FieldInfo::FieldFlags fflags) : 152 _index(0), 153 _name_index(name_index), 154 _signature_index(signature_index), 155 _offset(0), 156 _access_flags(access_flags), 157 _field_flags(fflags), 158 _initializer_index(initval_index), 159 _generic_signature_index(0), 160 _contention_group(0) { 161 if (initval_index != 0) { 162 _field_flags.update_initialized(true); 163 } 164 } 165 166 u4 index() const { return _index; } 167 void set_index(u4 index) { _index = index; } 168 u2 name_index() const { return _name_index; } 169 void set_name_index(u2 index) { _name_index = index; } 170 u2 signature_index() const { return _signature_index; } 171 void set_signature_index(u2 index) { _signature_index = index; } 172 u4 offset() const { return _offset; } 173 void set_offset(u4 offset) { _offset = offset; } 174 AccessFlags access_flags() const { return _access_flags; } 175 FieldFlags field_flags() const { return _field_flags; } 176 FieldFlags* field_flags_addr() { return &_field_flags; } 177 u2 initializer_index() const { return _initializer_index; } 178 void set_initializer_index(u2 index) { _initializer_index = index; } 179 u2 generic_signature_index() const { return _generic_signature_index; } 180 void set_generic_signature_index(u2 index) { _generic_signature_index = index; } 181 u2 contention_group() const { return _contention_group; } 182 183 bool is_contended() const { 184 return _field_flags.is_contended(); 185 } 186 187 u2 contended_group() const { 188 assert(is_contended(), ""); 189 return _contention_group; 190 } 191 192 void set_contended_group(u2 group) { 193 _field_flags.update_contended(true); 194 _contention_group = group; 195 } 196 197 bool is_offset_set() const { 198 return _offset != 0; 199 } 200 201 inline Symbol* name(ConstantPool* cp) const; 202 203 inline Symbol* signature(ConstantPool* cp) const; 204 205 inline Symbol* lookup_symbol(int symbol_index) const; 206 207 void print(outputStream* os, ConstantPool* cp); 208 void static print_from_growable_array(outputStream* os, GrowableArray<FieldInfo>* array, ConstantPool* cp); 209 }; 210 211 class FieldInfoStream; 212 213 // Gadget for sizing and/or writing a stream of field records. 214 template<typename CON> 215 class Mapper { 216 CON* _consumer; // can be UNSIGNED5::Writer or UNSIGNED5::Sizer 217 int _next_index; 218 public: 219 Mapper(CON* consumer) : _consumer(consumer) { _next_index = 0; } 220 int next_index() const { return _next_index; } 221 void set_next_index(int next_index) { _next_index = next_index; } 222 CON* consumer() const { return _consumer; } 223 void map_field_info(const FieldInfo& fi); 224 }; 225 226 // Gadget for decoding and reading the stream of field records. 227 class FieldInfoReader { 228 UNSIGNED5::Reader<const u1*, int> _r; 229 int _next_index; 230 231 public: 232 FieldInfoReader(const Array<u1>* fi); 233 234 private: 235 inline uint32_t next_uint() { return _r.next_uint(); } 236 void skip(int n) { int s = _r.try_skip(n); assert(s == n,""); } 237 238 public: 239 void read_field_counts(int* java_fields, int* injected_fields); 240 int has_next() const { return _r.position() < _r.limit(); } 241 int position() const { return _r.position(); } 242 int next_index() const { return _next_index; } 243 void read_name_and_signature(u2* name_index, u2* signature_index); 244 void read_field_info(FieldInfo& fi); 245 246 int search_table_lookup(const Array<u1>* search_table, const Symbol* name, const Symbol* signature, ConstantPool* cp, int java_fields); 247 248 // skip a whole field record, both required and optional bits 249 FieldInfoReader& skip_field_info(); 250 251 // Skip to the nth field. If the reader is freshly initialized to 252 // the zero index, this will call skip_field_info() n times. 253 FieldInfoReader& skip_to_field_info(int n); 254 255 // for random access, if you know where to go up front: 256 FieldInfoReader& set_position_and_next_index(int position, int next_index); 257 }; 258 259 // The format of the stream, after decompression, is a series of 260 // integers organized like this: 261 // 262 // FieldInfoStream := j=num_java_fields k=num_injected_fields Field[j+k] End 263 // Field := name sig offset access flags Optionals(flags) 264 // Optionals(i) := initval?[i&is_init] // ConstantValue attr 265 // gsig?[i&is_generic] // signature attr 266 // group?[i&is_contended] // Contended anno (group) 267 // End = 0 268 // 269 class FieldInfoStream : AllStatic { 270 friend class fieldDescriptor; 271 friend class JavaFieldStream; 272 friend class FieldStreamBase; 273 friend class ClassFileParser; 274 friend class FieldInfoReader; 275 friend class FieldInfoComparator; 276 277 private: 278 static int compare_name_and_sig(const Symbol* n1, const Symbol* s1, const Symbol* n2, const Symbol* s2); 279 280 public: 281 static int num_java_fields(const Array<u1>* fis); 282 static int num_injected_java_fields(const Array<u1>* fis); 283 static int num_total_fields(const Array<u1>* fis); 284 285 static Array<u1>* create_FieldInfoStream(GrowableArray<FieldInfo>* fields, int java_fields, int injected_fields, 286 ClassLoaderData* loader_data, TRAPS); 287 static Array<u1>* create_search_table(ConstantPool* cp, const Array<u1>* fis, ClassLoaderData* loader_data, TRAPS); 288 static GrowableArray<FieldInfo>* create_FieldInfoArray(const Array<u1>* fis, int* java_fields_count, int* injected_fields_count); 289 static void print_from_fieldinfo_stream(Array<u1>* fis, outputStream* os, ConstantPool* cp); 290 291 DEBUG_ONLY(static void validate_search_table(ConstantPool* cp, const Array<u1>* fis, const Array<u1>* search_table);) 292 293 static void print_search_table(outputStream* st, ConstantPool* cp, const Array<u1>* fis, const Array<u1>* search_table); 294 }; 295 296 class FieldStatus { 297 enum FieldStatusBitPosition { 298 _fs_access_watched, // field access is watched by JVMTI 299 _fs_modification_watched, // field modification is watched by JVMTI 300 _initialized_final_update // (static) final field updated outside (class) initializer 301 }; 302 303 // boilerplate: 304 u1 _flags; 305 static constexpr u1 flag_mask(FieldStatusBitPosition pos) { return (u1)1 << (int)pos; } 306 bool test_flag(FieldStatusBitPosition pos) { return (_flags & flag_mask(pos)) != 0; } 307 // this performs an atomic update on a live status byte! 308 void update_flag(FieldStatusBitPosition pos, bool z); 309 // out-of-line functions do a CAS-loop 310 static void atomic_set_bits(u1& flags, u1 mask); 311 static void atomic_clear_bits(u1& flags, u1 mask); 312 313 public: 314 FieldStatus() { _flags = 0; } 315 FieldStatus(u1 flags) { _flags = flags; } 316 u1 as_uint() { return _flags; } 317 318 bool is_access_watched() { return test_flag(_fs_access_watched); } 319 bool is_modification_watched() { return test_flag(_fs_modification_watched); } 320 bool is_initialized_final_update() { return test_flag(_initialized_final_update); } 321 322 void update_access_watched(bool z); 323 void update_modification_watched(bool z); 324 void update_initialized_final_update(bool z); 325 }; 326 327 #endif // SHARE_OOPS_FIELDINFO_HPP --- EOF ---