1 /* 2 * Copyright (c) 1997, 2023, 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_SYSTEMDICTIONARY_HPP 26 #define SHARE_CLASSFILE_SYSTEMDICTIONARY_HPP 27 28 #include "oops/oopHandle.hpp" 29 #include "runtime/handles.hpp" 30 #include "runtime/signature.hpp" 31 #include "utilities/vmEnums.hpp" 32 33 // The dictionary in each ClassLoaderData stores all loaded classes, either 34 // initiatied by its class loader or defined by its class loader: 35 // 36 // class loader -> ClassLoaderData -> [class, protection domain set] 37 // 38 // Classes are loaded lazily. The default VM class loader is 39 // represented as null. 40 41 // The underlying data structure is an open hash table (Dictionary) per 42 // ClassLoaderData with a fixed number of buckets. During loading the 43 // class loader object is locked, (for the VM loader a private lock object is used). 44 // The global SystemDictionary_lock is held for all additions into the ClassLoaderData 45 // dictionaries. TODO: fix lock granularity so that class loading can 46 // be done concurrently, but only by different loaders. 47 // 48 // During loading a placeholder (name, loader) is temporarily placed in 49 // a side data structure, and is used to detect ClassCircularityErrors. 50 // 51 // When class loading is finished, a new entry is added to the dictionary 52 // of the class loader and the placeholder is removed. Note that the protection 53 // domain field of the dictionary entry has not yet been filled in when 54 // the "real" dictionary entry is created. 55 // 56 // Clients of this class who are interested in finding if a class has 57 // been completely loaded -- not classes in the process of being loaded -- 58 // can read the dictionary unlocked. This is safe because 59 // - entries are only deleted when the class loader is not alive, when the 60 // entire dictionary is deleted. 61 // - entries must be fully formed before they are available to concurrent 62 // readers (we must ensure write ordering) 63 // 64 // Note that placeholders are deleted at any time, as they are removed 65 // when a class is completely loaded. Therefore, readers as well as writers 66 // of placeholders must hold the SystemDictionary_lock. 67 // 68 69 class BootstrapInfo; 70 class ClassFileStream; 71 class ClassLoadInfo; 72 class Dictionary; 73 class AllFieldStream; 74 class PackageEntry; 75 class GCTimer; 76 class EventClassLoad; 77 class Symbol; 78 79 class SystemDictionary : AllStatic { 80 friend class BootstrapInfo; 81 friend class vmClasses; 82 friend class VMStructs; 83 84 public: 85 86 // Returns a class with a given class name and class loader. Loads the 87 // class if needed. If not found a NoClassDefFoundError or a 88 // ClassNotFoundException is thrown, depending on the value on the 89 // throw_error flag. For most uses the throw_error argument should be set 90 // to true. 91 92 static Klass* resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS); 93 // Convenient call for null loader and protection domain. 94 static Klass* resolve_or_fail(Symbol* class_name, bool throw_error, TRAPS) { 95 return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD); 96 } 97 98 // Returns a class with a given class name and class loader. 99 // Loads the class if needed. If not found null is returned. 100 static Klass* resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); 101 // Version with null loader and protection domain 102 static Klass* resolve_or_null(Symbol* class_name, TRAPS) { 103 return resolve_or_null(class_name, Handle(), Handle(), THREAD); 104 } 105 106 // Resolve a superclass or superinterface. Called from ClassFileParser, 107 // parse_interfaces, resolve_instance_class_or_null, load_shared_class 108 // "class_name" is the class whose super class or interface is being resolved. 109 static InstanceKlass* resolve_super_or_fail(Symbol* class_name, 110 Symbol* super_name, 111 Handle class_loader, 112 Handle protection_domain, 113 bool is_superclass, 114 TRAPS); 115 private: 116 // Parse the stream to create a hidden class. 117 // Used by jvm_lookup_define_class. 118 static InstanceKlass* resolve_hidden_class_from_stream(ClassFileStream* st, 119 Symbol* class_name, 120 Handle class_loader, 121 const ClassLoadInfo& cl_info, 122 TRAPS); 123 124 // Resolve a class from stream (called by jni_DefineClass and JVM_DefineClass) 125 // This class is added to the SystemDictionary. 126 static InstanceKlass* resolve_class_from_stream(ClassFileStream* st, 127 Symbol* class_name, 128 Handle class_loader, 129 const ClassLoadInfo& cl_info, 130 TRAPS); 131 132 static oop get_system_class_loader_impl(TRAPS); 133 static oop get_platform_class_loader_impl(TRAPS); 134 135 public: 136 static Klass* resolve_inline_type_field_or_fail(Symbol* signature, 137 Handle class_loader, 138 Handle protection_domain, 139 bool throw_error, 140 TRAPS); 141 142 // Resolve either a hidden or normal class from a stream of bytes, based on ClassLoadInfo 143 static InstanceKlass* resolve_from_stream(ClassFileStream* st, 144 Symbol* class_name, 145 Handle class_loader, 146 const ClassLoadInfo& cl_info, 147 TRAPS); 148 149 // Lookup an already loaded class. If not found null is returned. 150 static InstanceKlass* find_instance_klass(Thread* current, Symbol* class_name, 151 Handle class_loader, Handle protection_domain); 152 153 // Lookup an already loaded instance or array class. 154 // Do not make any queries to class loaders; consult only the cache. 155 // If not found null is returned. 156 static Klass* find_instance_or_array_klass(Thread* current, Symbol* class_name, 157 Handle class_loader, 158 Handle protection_domain); 159 160 // Lookup an instance or array class that has already been loaded 161 // either into the given class loader, or else into another class 162 // loader that is constrained (via loader constraints) to produce 163 // a consistent class. Do not take protection domains into account. 164 // Do not make any queries to class loaders; consult only the cache. 165 // Return null if the class is not found. 166 // 167 // This function is a strict superset of find_instance_or_array_klass. 168 // This function (the unchecked version) makes a conservative prediction 169 // of the result of the checked version, assuming successful lookup. 170 // If both functions return non-null, they must return the same value. 171 // Also, the unchecked version may sometimes be non-null where the 172 // checked version is null. This can occur in several ways: 173 // 1. No query has yet been made to the class loader. 174 // 2. The class loader was queried, but chose not to delegate. 175 // 3. ClassLoader.checkPackageAccess rejected a proposed protection domain. 176 // 4. Loading was attempted, but there was a linkage error of some sort. 177 // In all of these cases, the loader constraints on this type are 178 // satisfied, and it is safe for classes in the given class loader 179 // to manipulate strongly-typed values of the found class, subject 180 // to local linkage and access checks. 181 static Klass* find_constrained_instance_or_array_klass(Thread* current, 182 Symbol* class_name, 183 Handle class_loader); 184 185 static void classes_do(MetaspaceClosure* it); 186 // Iterate over all methods in all klasses 187 188 static void methods_do(void f(Method*)); 189 190 // Garbage collection support 191 192 // Unload (that is, break root links to) all unmarked classes and 193 // loaders. Returns "true" iff something was unloaded. 194 static bool do_unloading(GCTimer* gc_timer); 195 196 // Printing 197 static void print(); 198 static void print_on(outputStream* st); 199 static void dump(outputStream* st, bool verbose); 200 201 // Verification 202 static void verify(); 203 204 // Initialization 205 static void initialize(TRAPS); 206 207 public: 208 // Returns java system loader 209 static oop java_system_loader(); 210 211 // Returns java platform loader 212 static oop java_platform_loader(); 213 214 // Compute the java system and platform loaders 215 static void compute_java_loaders(TRAPS); 216 217 // Register a new class loader 218 static ClassLoaderData* register_loader(Handle class_loader, bool create_mirror_cld = false); 219 220 static void set_system_loader(ClassLoaderData *cld); 221 static void set_platform_loader(ClassLoaderData *cld); 222 223 static Symbol* check_signature_loaders(Symbol* signature, Klass* klass_being_linked, 224 Handle loader1, Handle loader2, bool is_method); 225 226 // JSR 292 227 // find a java.lang.invoke.MethodHandle.invoke* method for a given signature 228 // (asks Java to compute it if necessary, except in a compiler thread) 229 static Method* find_method_handle_invoker(Klass* klass, 230 Symbol* name, 231 Symbol* signature, 232 Klass* accessing_klass, 233 Handle *appendix_result, 234 TRAPS); 235 // for a given signature, find the internal MethodHandle method (linkTo* or invokeBasic) 236 // (does not ask Java, since this is a low-level intrinsic defined by the JVM) 237 static Method* find_method_handle_intrinsic(vmIntrinsicID iid, 238 Symbol* signature, 239 TRAPS); 240 241 // compute java_mirror (java.lang.Class instance) for a type ("I", "[[B", "LFoo;", etc.) 242 // Either the accessing_klass or the CL/PD can be non-null, but not both. 243 static Handle find_java_mirror_for_type(Symbol* signature, 244 Klass* accessing_klass, 245 Handle class_loader, 246 Handle protection_domain, 247 SignatureStream::FailureMode failure_mode, 248 TRAPS); 249 static Handle find_java_mirror_for_type(Symbol* signature, 250 Klass* accessing_klass, 251 SignatureStream::FailureMode failure_mode, 252 TRAPS) { 253 // callee will fill in CL/PD from AK, if they are needed 254 return find_java_mirror_for_type(signature, accessing_klass, Handle(), Handle(), 255 failure_mode, THREAD); 256 } 257 258 // find a java.lang.invoke.MethodType object for a given signature 259 // (asks Java to compute it if necessary, except in a compiler thread) 260 static Handle find_method_handle_type(Symbol* signature, 261 Klass* accessing_klass, 262 TRAPS); 263 264 // find a java.lang.Class object for a given signature 265 static Handle find_field_handle_type(Symbol* signature, 266 Klass* accessing_klass, 267 TRAPS); 268 269 // ask Java to compute a java.lang.invoke.MethodHandle object for a given CP entry 270 static Handle link_method_handle_constant(Klass* caller, 271 int ref_kind, //e.g., JVM_REF_invokeVirtual 272 Klass* callee, 273 Symbol* name, 274 Symbol* signature, 275 TRAPS); 276 277 // ask Java to compute a constant by invoking a BSM given a Dynamic_info CP entry 278 static void invoke_bootstrap_method(BootstrapInfo& bootstrap_specifier, TRAPS); 279 280 // Record the error when the first attempt to resolve a reference from a constant 281 // pool entry to a class fails. 282 static void add_resolution_error(const constantPoolHandle& pool, int which, Symbol* error, 283 Symbol* message, Symbol* cause = nullptr, Symbol* cause_msg = nullptr); 284 static void delete_resolution_error(ConstantPool* pool); 285 static Symbol* find_resolution_error(const constantPoolHandle& pool, int which, 286 Symbol** message, Symbol** cause, Symbol** cause_msg); 287 288 289 // Record a nest host resolution/validation error 290 static void add_nest_host_error(const constantPoolHandle& pool, int which, 291 const char* message); 292 static const char* find_nest_host_error(const constantPoolHandle& pool, int which); 293 294 protected: 295 static InstanceKlass* _well_known_klasses[]; 296 297 private: 298 // table of box klasses (int_klass, etc.) 299 static InstanceKlass* _box_klasses[T_VOID+1]; 300 301 static OopHandle _java_system_loader; 302 static OopHandle _java_platform_loader; 303 304 private: 305 // Basic loading operations 306 static InstanceKlass* resolve_instance_class_or_null(Symbol* class_name, 307 Handle class_loader, 308 Handle protection_domain, TRAPS); 309 static Klass* resolve_array_class_or_null(Symbol* class_name, 310 Handle class_loader, 311 Handle protection_domain, TRAPS); 312 static void define_instance_class(InstanceKlass* k, Handle class_loader, TRAPS); 313 static InstanceKlass* find_or_define_helper(Symbol* class_name, 314 Handle class_loader, 315 InstanceKlass* k, TRAPS); 316 static InstanceKlass* load_instance_class_impl(Symbol* class_name, Handle class_loader, TRAPS); 317 static InstanceKlass* load_instance_class(Symbol* class_name, 318 Handle class_loader, TRAPS); 319 320 // Class loader constraints 321 static void check_constraints(InstanceKlass* k, ClassLoaderData* loader, 322 bool defining, TRAPS); 323 static void update_dictionary(JavaThread* current, InstanceKlass* k, ClassLoaderData* loader_data); 324 325 static bool is_shared_class_visible(Symbol* class_name, InstanceKlass* ik, 326 PackageEntry* pkg_entry, 327 Handle class_loader); 328 static bool is_shared_class_visible_impl(Symbol* class_name, 329 InstanceKlass* ik, 330 PackageEntry* pkg_entry, 331 Handle class_loader); 332 static bool check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super, 333 Handle class_loader, Handle protection_domain, 334 bool is_superclass, TRAPS); 335 static bool check_shared_class_super_types(InstanceKlass* ik, Handle class_loader, 336 Handle protection_domain, TRAPS); 337 // Second part of load_shared_class 338 static void load_shared_class_misc(InstanceKlass* ik, ClassLoaderData* loader_data) NOT_CDS_RETURN; 339 340 protected: 341 // Used by SystemDictionaryShared 342 343 static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked, Handle loader1, 344 Handle loader2); 345 static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld); 346 static InstanceKlass* load_shared_lambda_proxy_class(InstanceKlass* ik, 347 Handle class_loader, 348 Handle protection_domain, 349 PackageEntry* pkg_entry, 350 TRAPS); 351 static InstanceKlass* load_shared_class(InstanceKlass* ik, 352 Handle class_loader, 353 Handle protection_domain, 354 const ClassFileStream *cfs, 355 PackageEntry* pkg_entry, 356 TRAPS); 357 static Handle get_loader_lock_or_null(Handle class_loader); 358 static InstanceKlass* find_or_define_instance_class(Symbol* class_name, 359 Handle class_loader, 360 InstanceKlass* k, TRAPS); 361 public: 362 static bool is_system_class_loader(oop class_loader); 363 static bool is_platform_class_loader(oop class_loader); 364 static bool is_boot_class_loader(oop class_loader) { return class_loader == nullptr; } 365 static bool is_builtin_class_loader(oop class_loader) { 366 return is_boot_class_loader(class_loader) || 367 is_platform_class_loader(class_loader) || 368 is_system_class_loader(class_loader); 369 } 370 // Returns TRUE if the method is a non-public member of class java.lang.Object. 371 static bool is_nonpublic_Object_method(Method* m); 372 373 // Return Symbol or throw exception if name given is can not be a valid Symbol. 374 static Symbol* class_name_symbol(const char* name, Symbol* exception, TRAPS); 375 }; 376 377 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARY_HPP