1 /* 2 * Copyright (c) 2014, 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_SYSTEMDICTIONARYSHARED_HPP 26 #define SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP 27 28 #include "cds/cds_globals.hpp" 29 #include "cds/dumpTimeClassInfo.hpp" 30 #include "cds/filemap.hpp" 31 #include "cds/runTimeClassInfo.hpp" 32 #include "classfile/classLoaderData.hpp" 33 #include "classfile/packageEntry.hpp" 34 #include "classfile/systemDictionary.hpp" 35 #include "oops/klass.hpp" 36 #include "oops/oopHandle.hpp" 37 38 39 /*=============================================================================== 40 41 Handling of the classes in the AppCDS archive 42 43 To ensure safety and to simplify the implementation, archived classes are 44 "segregated" into 2 types. The following rules describe how they 45 are stored and looked up. 46 47 [1] Category of archived classes 48 49 There are 2 disjoint groups of classes stored in the AppCDS archive: 50 51 BUILTIN: These classes may be defined ONLY by the BOOT/PLATFORM/APP 52 loaders. 53 54 UNREGISTERED: These classes may be defined ONLY by a ClassLoader 55 instance that's not listed above (using fingerprint matching) 56 57 [2] How classes from different categories are specified in the classlist: 58 59 Starting from JDK9, each class in the classlist may be specified with 60 these keywords: "id", "super", "interfaces", "loader" and "source". 61 62 63 BUILTIN Only the "id" keyword may be (optionally) specified. All other 64 keywords are forbidden. 65 66 The named class is looked up from the jimage and from 67 Xbootclasspath/a and CLASSPATH. 68 69 UNREGISTERED: The "id", "super", and "source" keywords must all be 70 specified. 71 72 The "interfaces" keyword must be specified if the class implements 73 one or more local interfaces. The "interfaces" keyword must not be 74 specified if the class does not implement local interfaces. 75 76 The named class is looked up from the location specified in the 77 "source" keyword. 78 79 Example classlist: 80 81 # BUILTIN 82 java/lang/Object id: 0 83 java/lang/Cloneable id: 1 84 java/lang/String 85 86 # UNREGISTERED 87 Bar id: 3 super: 0 interfaces: 1 source: /foo.jar 88 89 90 [3] Identifying the category of archived classes 91 92 BUILTIN: (C->shared_classpath_index() >= 0) 93 UNREGISTERED: (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999)) 94 95 [4] Lookup of archived classes at run time: 96 97 (a) BUILTIN loaders: 98 99 search _builtin_dictionary 100 101 (b) UNREGISTERED loaders: 102 103 search _unregistered_dictionary for an entry that matches the 104 (name, clsfile_len, clsfile_crc32). 105 106 ===============================================================================*/ 107 #define UNREGISTERED_INDEX -9999 108 109 class BootstrapInfo; 110 class ClassFileStream; 111 class ConstantPoolCache; 112 class Dictionary; 113 class DumpTimeClassInfo; 114 class DumpTimeSharedClassTable; 115 class RunTimeClassInfo; 116 class RunTimeSharedDictionary; 117 118 template <typename E> class GrowableArray; 119 120 class SharedClassLoadingMark { 121 private: 122 Thread* THREAD; 123 InstanceKlass* _klass; 124 public: 125 SharedClassLoadingMark(Thread* current, InstanceKlass* ik) : THREAD(current), _klass(ik) {} 126 ~SharedClassLoadingMark() { 127 assert(THREAD != nullptr, "Current thread is nullptr"); 128 assert(_klass != nullptr, "InstanceKlass is nullptr"); 129 if (HAS_PENDING_EXCEPTION) { 130 if (_klass->in_aot_cache()) { 131 _klass->set_shared_loading_failed(); 132 } 133 } 134 } 135 }; 136 137 class SystemDictionaryShared: public SystemDictionary { 138 friend class LambdaProxyClassDictionary; 139 140 struct ArchiveInfo { 141 RunTimeSharedDictionary _builtin_dictionary; 142 RunTimeSharedDictionary _unregistered_dictionary; 143 144 void print_on(const char* prefix, outputStream* st, bool is_static_archive); 145 void print_table_statistics(const char* prefix, outputStream* st, bool is_static_archive); 146 }; 147 148 private: 149 150 static DumpTimeSharedClassTable* _dumptime_table; 151 152 static ArchiveInfo _static_archive; 153 static ArchiveInfo _dynamic_archive; 154 155 static ArchiveInfo* get_archive(bool is_static_archive) { 156 return is_static_archive ? &_static_archive : &_dynamic_archive; 157 } 158 159 static InstanceKlass* load_shared_class_for_builtin_loader( 160 Symbol* class_name, 161 Handle class_loader, 162 TRAPS); 163 static InstanceKlass* acquire_class_for_current_thread( 164 InstanceKlass *ik, 165 Handle class_loader, 166 Handle protection_domain, 167 const ClassFileStream* cfs, 168 TRAPS); 169 170 // Guaranteed to return non-null value for non-shared classes. 171 // k must not be a shared class. 172 static DumpTimeClassInfo* get_info(InstanceKlass* k); 173 static DumpTimeClassInfo* get_info_locked(InstanceKlass* k); 174 175 static void write_dictionary(RunTimeSharedDictionary* dictionary, 176 bool is_builtin); 177 static bool is_jfr_event_class(InstanceKlass *k); 178 static bool check_for_exclusion_impl(InstanceKlass* k); 179 static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN; 180 static bool has_been_redefined(InstanceKlass* k); 181 DEBUG_ONLY(static bool _class_loading_may_happen;) 182 183 static void copy_verification_constraints_from_preimage(InstanceKlass* klass); 184 static void copy_linking_constraints_from_preimage(InstanceKlass* klass); 185 186 public: 187 static bool is_early_klass(InstanceKlass* k); // Was k loaded while JvmtiExport::is_early_phase()==true 188 static bool has_archived_enum_objs(InstanceKlass* ik); 189 static void set_has_archived_enum_objs(InstanceKlass* ik); 190 191 static InstanceKlass* find_builtin_class(Symbol* class_name); 192 193 static const RunTimeClassInfo* find_record(RunTimeSharedDictionary* static_dict, 194 RunTimeSharedDictionary* dynamic_dict, 195 Symbol* name); 196 197 static bool has_platform_or_app_classes(); 198 199 // Called by PLATFORM/APP loader only 200 static InstanceKlass* find_or_load_shared_class(Symbol* class_name, 201 Handle class_loader, 202 TRAPS); 203 204 205 static void allocate_shared_data_arrays(int size, TRAPS); 206 207 static bool is_builtin_loader(ClassLoaderData* loader_data); 208 209 static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name, 210 Symbol* super_name, bool is_superclass); 211 212 static void initialize() NOT_CDS_RETURN; 213 static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN; 214 static void init_dumptime_info_from_preimage(InstanceKlass* k) NOT_CDS_RETURN; 215 static void handle_class_unloading(InstanceKlass* k) NOT_CDS_RETURN; 216 217 static Dictionary* boot_loader_dictionary() { 218 return ClassLoaderData::the_null_class_loader_data()->dictionary(); 219 } 220 221 static void update_shared_entry(InstanceKlass* klass, int id); 222 static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs); 223 224 static InstanceKlass* lookup_from_stream(Symbol* class_name, 225 Handle class_loader, 226 Handle protection_domain, 227 const ClassFileStream* st, 228 TRAPS); 229 // "verification_constraints" are a set of checks performed by 230 // VerificationType::is_reference_assignable_from when verifying a shared class during 231 // dump time. 232 // 233 // With AppCDS, it is possible to override archived classes by calling 234 // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already 235 // ensures that you cannot load a shared class if its super type(s) are changed. However, 236 // we need an additional check to ensure that the verification_constraints did not change 237 // between dump time and runtime. 238 static void add_verification_constraint(InstanceKlass* k, Symbol* name, 239 Symbol* from_name, bool from_field_is_protected, 240 bool from_is_array, bool from_is_object, 241 bool* skip_assignability_check); 242 static void check_verification_constraints(InstanceKlass* klass, 243 TRAPS) NOT_CDS_RETURN; 244 static void add_enum_klass_static_field(InstanceKlass* ik, int root_index); 245 static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN; 246 static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false); 247 static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false); 248 static void record_linking_constraint(Symbol* name, InstanceKlass* klass, 249 Handle loader1, Handle loader2) NOT_CDS_RETURN; 250 static bool is_builtin(const InstanceKlass* k) { 251 return (k->shared_classpath_index() != UNREGISTERED_INDEX); 252 } 253 static bool add_unregistered_class(Thread* current, InstanceKlass* k); 254 static InstanceKlass* get_unregistered_class(Symbol* name); 255 static void copy_unregistered_class_size_and_crc32(InstanceKlass* klass); 256 257 static void finish_exclusion_checks(); 258 static DumpTimeSharedClassTable* dumptime_table() { return _dumptime_table; } 259 260 static bool should_be_excluded(Klass* k); 261 static bool check_for_exclusion(InstanceKlass* k, DumpTimeClassInfo* info); 262 static void validate_before_archiving(InstanceKlass* k); 263 static bool is_excluded_class(InstanceKlass* k); 264 static void set_excluded(InstanceKlass* k); 265 static void set_excluded_locked(InstanceKlass* k); 266 static void set_from_class_file_load_hook(InstanceKlass* k) NOT_CDS_RETURN; 267 static bool warn_excluded(InstanceKlass* k, const char* reason); 268 static void dumptime_classes_do(class MetaspaceClosure* it); 269 static void write_to_archive(bool is_static_archive = true); 270 static void serialize_dictionary_headers(class SerializeClosure* soc, 271 bool is_static_archive = true); 272 static void serialize_vm_classes(class SerializeClosure* soc); 273 static const char* loader_type_for_shared_class(Klass* k); 274 static void get_all_archived_classes(bool is_static_archive, GrowableArray<Klass*>* classes); 275 static void print() { return print_on(tty); } 276 static void print_on(outputStream* st) NOT_CDS_RETURN; 277 static void print_shared_archive(outputStream* st, bool is_static = true) NOT_CDS_RETURN; 278 static void print_table_statistics(outputStream* st) NOT_CDS_RETURN; 279 static bool is_dumptime_table_empty() NOT_CDS_RETURN_(true); 280 DEBUG_ONLY(static bool class_loading_may_happen() {return _class_loading_may_happen;}) 281 282 #ifdef ASSERT 283 // This object marks a critical period when writing the CDS archive. During this 284 // period, the JVM must not load any new classes, so as to avoid adding new 285 // items in the SystemDictionaryShared::_dumptime_table. 286 class NoClassLoadingMark: public StackObj { 287 public: 288 NoClassLoadingMark() { 289 assert(_class_loading_may_happen, "must not be nested"); 290 _class_loading_may_happen = false; 291 } 292 ~NoClassLoadingMark() { 293 _class_loading_may_happen = true; 294 } 295 }; 296 #endif 297 298 template <typename T> 299 static unsigned int hash_for_shared_dictionary_quick(T* ptr) { 300 assert(MetaspaceObj::in_aot_cache((const MetaspaceObj*)ptr), "must be"); 301 assert(ptr > (T*)SharedBaseAddress, "must be"); 302 uintx offset = uintx(ptr) - uintx(SharedBaseAddress); 303 return primitive_hash<uintx>(offset); 304 } 305 306 static unsigned int hash_for_shared_dictionary(address ptr); 307 }; 308 309 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP