1 /* 2 * Copyright (c) 2021, 2024, 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_CDS_DUMPTIMECLASSINFO_HPP 26 #define SHARE_CDS_DUMPTIMECLASSINFO_HPP 27 28 #include "cds/archiveBuilder.hpp" 29 #include "cds/archiveUtils.hpp" 30 #include "cds/cdsConfig.hpp" 31 #include "cds/metaspaceShared.hpp" 32 #include "classfile/compactHashtable.hpp" 33 #include "memory/metaspaceClosure.hpp" 34 #include "oops/instanceKlass.hpp" 35 #include "prims/jvmtiExport.hpp" 36 #include "utilities/growableArray.hpp" 37 38 class Method; 39 class Symbol; 40 41 class DumpTimeClassInfo: public CHeapObj<mtClass> { 42 bool _excluded; 43 bool _is_early_klass; 44 bool _has_checked_exclusion; 45 bool _can_be_preinited; 46 bool _has_done_preinit_check; 47 48 class DTLoaderConstraint { 49 Symbol* _name; 50 char _loader_type1; 51 char _loader_type2; 52 public: 53 DTLoaderConstraint() : _name(nullptr), _loader_type1('0'), _loader_type2('0') {} 54 DTLoaderConstraint(Symbol* name, char l1, char l2) : _name(name), _loader_type1(l1), _loader_type2(l2) { 55 Symbol::maybe_increment_refcount(_name); 56 } 57 DTLoaderConstraint(const DTLoaderConstraint& src) { 58 _name = src._name; 59 _loader_type1 = src._loader_type1; 60 _loader_type2 = src._loader_type2; 61 Symbol::maybe_increment_refcount(_name); 62 } 63 DTLoaderConstraint& operator=(DTLoaderConstraint src) { 64 swap(_name, src._name); // c++ copy-and-swap idiom 65 _loader_type1 = src._loader_type1; 66 _loader_type2 = src._loader_type2; 67 return *this; 68 } 69 ~DTLoaderConstraint() { 70 Symbol::maybe_decrement_refcount(_name); 71 } 72 73 bool equals(const DTLoaderConstraint& t) { 74 return t._name == _name && 75 ((t._loader_type1 == _loader_type1 && t._loader_type2 == _loader_type2) || 76 (t._loader_type2 == _loader_type1 && t._loader_type1 == _loader_type2)); 77 } 78 void metaspace_pointers_do(MetaspaceClosure* it) { 79 it->push(&_name); 80 } 81 82 Symbol* name() { return _name; } 83 char loader_type1() { return _loader_type1; } 84 char loader_type2() { return _loader_type2; } 85 }; 86 87 class DTVerifierConstraint { 88 Symbol* _name; 89 Symbol* _from_name; 90 public: 91 DTVerifierConstraint() : _name(nullptr), _from_name(nullptr) {} 92 DTVerifierConstraint(Symbol* n, Symbol* fn) : _name(n), _from_name(fn) { 93 Symbol::maybe_increment_refcount(_name); 94 Symbol::maybe_increment_refcount(_from_name); 95 } 96 DTVerifierConstraint(const DTVerifierConstraint& src) { 97 _name = src._name; 98 _from_name = src._from_name; 99 Symbol::maybe_increment_refcount(_name); 100 Symbol::maybe_increment_refcount(_from_name); 101 } 102 DTVerifierConstraint& operator=(DTVerifierConstraint src) { 103 swap(_name, src._name); // c++ copy-and-swap idiom 104 swap(_from_name, src._from_name); // c++ copy-and-swap idiom 105 return *this; 106 } 107 ~DTVerifierConstraint() { 108 Symbol::maybe_decrement_refcount(_name); 109 Symbol::maybe_decrement_refcount(_from_name); 110 } 111 bool equals(Symbol* n, Symbol* fn) { 112 return (_name == n) && (_from_name == fn); 113 } 114 void metaspace_pointers_do(MetaspaceClosure* it) { 115 it->push(&_name); 116 it->push(&_from_name); 117 } 118 119 Symbol* name() { return _name; } 120 Symbol* from_name() { return _from_name; } 121 }; 122 123 public: 124 InstanceKlass* _klass; 125 InstanceKlass* _nest_host; 126 bool _failed_verification; 127 bool _is_archived_lambda_proxy; 128 int _id; 129 int _clsfile_size; 130 int _clsfile_crc32; 131 GrowableArray<DTVerifierConstraint>* _verifier_constraints; 132 GrowableArray<char>* _verifier_constraint_flags; 133 GrowableArray<DTLoaderConstraint>* _loader_constraints; 134 GrowableArray<int>* _enum_klass_static_fields; 135 136 DumpTimeClassInfo() { 137 _klass = nullptr; 138 _nest_host = nullptr; 139 _failed_verification = false; 140 _is_archived_lambda_proxy = false; 141 _has_checked_exclusion = false; 142 _can_be_preinited = false; 143 _has_done_preinit_check = false; 144 _id = -1; 145 _clsfile_size = -1; 146 _clsfile_crc32 = -1; 147 _excluded = false; 148 _is_early_klass = JvmtiExport::is_early_phase(); 149 _verifier_constraints = nullptr; 150 _verifier_constraint_flags = nullptr; 151 _loader_constraints = nullptr; 152 _enum_klass_static_fields = nullptr; 153 } 154 DumpTimeClassInfo& operator=(const DumpTimeClassInfo&) = delete; 155 ~DumpTimeClassInfo(); 156 157 void add_verification_constraint(InstanceKlass* k, Symbol* name, 158 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object); 159 void record_linking_constraint(Symbol* name, Handle loader1, Handle loader2); 160 void add_enum_klass_static_field(int archived_heap_root_index); 161 int enum_klass_static_field(int which_field); 162 bool is_builtin(); 163 164 private: 165 template <typename T> 166 static int array_length_or_zero(GrowableArray<T>* array) { 167 if (array == nullptr) { 168 return 0; 169 } else { 170 return array->length(); 171 } 172 } 173 174 public: 175 176 int num_verifier_constraints() const { 177 return array_length_or_zero(_verifier_constraint_flags); 178 } 179 180 int num_loader_constraints() const { 181 return array_length_or_zero(_loader_constraints); 182 } 183 184 int num_enum_klass_static_fields() const { 185 return array_length_or_zero(_enum_klass_static_fields); 186 } 187 188 void metaspace_pointers_do(MetaspaceClosure* it) { 189 it->push(&_klass); 190 it->push(&_nest_host); 191 if (_verifier_constraints != nullptr) { 192 for (int i = 0; i < _verifier_constraints->length(); i++) { 193 _verifier_constraints->adr_at(i)->metaspace_pointers_do(it); 194 } 195 } 196 if (_loader_constraints != nullptr) { 197 for (int i = 0; i < _loader_constraints->length(); i++) { 198 _loader_constraints->adr_at(i)->metaspace_pointers_do(it); 199 } 200 } 201 } 202 203 bool is_excluded(); 204 205 // Was this class loaded while JvmtiExport::is_early_phase()==true 206 bool is_early_klass() { 207 return _is_early_klass; 208 } 209 210 // simple accessors 211 void set_excluded() { _excluded = true; } 212 bool has_checked_exclusion() const { return _has_checked_exclusion; } 213 void set_has_checked_exclusion() { _has_checked_exclusion = true; } 214 bool failed_verification() const { return _failed_verification; } 215 void set_failed_verification() { _failed_verification = true; } 216 InstanceKlass* nest_host() const { return _nest_host; } 217 void set_nest_host(InstanceKlass* nest_host) { _nest_host = nest_host; } 218 219 bool can_be_preinited() const { return _can_be_preinited; } 220 bool has_done_preinit_check() const { return _has_done_preinit_check; } 221 222 void set_can_be_preinited(bool v) { 223 _can_be_preinited = v; 224 _has_done_preinit_check = true; 225 } 226 void reset_preinit_check() { 227 _can_be_preinited = false; 228 _has_done_preinit_check = false; 229 } 230 231 size_t runtime_info_bytesize() const; 232 }; 233 234 template <typename T> 235 inline unsigned DumpTimeSharedClassTable_hash(T* const& k) { 236 if (CDSConfig::is_dumping_static_archive()) { 237 // Deterministic archive contents 238 uintx delta = k->name() - MetaspaceShared::symbol_rs_base(); 239 return primitive_hash<uintx>(delta); 240 } else { 241 // Deterministic archive is not possible because classes can be loaded 242 // in multiple threads. 243 return primitive_hash<T*>(k); 244 } 245 } 246 247 using DumpTimeSharedClassTableBaseType = ResourceHashtable< 248 InstanceKlass*, 249 DumpTimeClassInfo, 250 15889, // prime number 251 AnyObj::C_HEAP, 252 mtClassShared, 253 &DumpTimeSharedClassTable_hash>; 254 255 class DumpTimeSharedClassTable: public DumpTimeSharedClassTableBaseType 256 { 257 int _builtin_count; 258 int _unregistered_count; 259 public: 260 DumpTimeSharedClassTable() { 261 _builtin_count = 0; 262 _unregistered_count = 0; 263 } 264 DumpTimeClassInfo* allocate_info(InstanceKlass* k); 265 DumpTimeClassInfo* get_info(InstanceKlass* k); 266 void inc_builtin_count() { _builtin_count++; } 267 void inc_unregistered_count() { _unregistered_count++; } 268 void update_counts(); 269 int count_of(bool is_builtin) const { 270 if (is_builtin) { 271 return _builtin_count; 272 } else { 273 return _unregistered_count; 274 } 275 } 276 277 template<class ITER> void iterate_all_live_classes(ITER* iter) const; 278 template<typename Function> void iterate_all_live_classes(Function function) const; 279 template<typename Function> void iterate_all_classes_in_builtin_loaders(Function function) const; 280 281 private: 282 // It's unsafe to iterate on classes whose loader is dead. 283 // Declare these private and don't implement them. This forces users of 284 // DumpTimeSharedClassTable to use the iterate_all_live_classes() methods 285 // instead. 286 template<class ITER> void iterate(ITER* iter) const; 287 template<typename Function> void iterate(Function function) const; 288 template<typename Function> void iterate_all(Function function) const; 289 }; 290 291 #endif // SHARE_CDS_DUMPTIMECLASSINFO_HPP