< prev index next >

src/hotspot/share/classfile/systemDictionary.hpp

Print this page

122   // Parse the stream to create a hidden class.
123   // Used by jvm_lookup_define_class.
124   static InstanceKlass* resolve_hidden_class_from_stream(ClassFileStream* st,
125                                                          Symbol* class_name,
126                                                          Handle class_loader,
127                                                          const ClassLoadInfo& cl_info,
128                                                          TRAPS);
129 
130   // Resolve a class from stream (called by jni_DefineClass and JVM_DefineClass)
131   // This class is added to the SystemDictionary.
132   static InstanceKlass* resolve_class_from_stream(ClassFileStream* st,
133                                                   Symbol* class_name,
134                                                   Handle class_loader,
135                                                   const ClassLoadInfo& cl_info,
136                                                   TRAPS);
137 
138   static oop get_system_class_loader_impl(TRAPS);
139   static oop get_platform_class_loader_impl(TRAPS);
140 
141  public:

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);
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 
159   // Lookup an instance or array class that has already been loaded
160   // either into the given class loader, or else into another class
161   // loader that is constrained (via loader constraints) to produce

267 
268   // ask Java to compute a constant by invoking a BSM given a Dynamic_info CP entry
269   static void      invoke_bootstrap_method(BootstrapInfo& bootstrap_specifier, TRAPS);
270 
271   // Record the error when the first attempt to resolve a reference from a constant
272   // pool entry to a class fails.
273   static void add_resolution_error(const constantPoolHandle& pool, int which,
274                                    Symbol* error, const char* message,
275                                    Symbol* cause = nullptr, const char* cause_msg = nullptr);
276   static void delete_resolution_error(ConstantPool* pool);
277   static Symbol* find_resolution_error(const constantPoolHandle& pool, int which,
278                                        const char** message,
279                                        Symbol** cause, const char** cause_msg);
280 
281   // Record a nest host resolution/validation error
282   static void add_nest_host_error(const constantPoolHandle& pool, int which,
283                                   const char* message);
284   static const char* find_nest_host_error(const constantPoolHandle& pool, int which);
285 
286   static void add_to_initiating_loader(JavaThread* current, InstanceKlass* k,
287                                        ClassLoaderData* loader_data) NOT_CDS_RETURN;
288 
289   static OopHandle  _java_system_loader;
290   static OopHandle  _java_platform_loader;
291 
292 private:
293   // Basic loading operations
294   static InstanceKlass* resolve_instance_class_or_null(Symbol* class_name,
295                                                        Handle class_loader,
296                                                        TRAPS);
297   static Klass* resolve_array_class_or_null(Symbol* class_name,
298                                             Handle class_loader,
299                                             TRAPS);
300   static void define_instance_class(InstanceKlass* k, Handle class_loader, TRAPS);
301   static InstanceKlass* find_or_define_helper(Symbol* class_name,
302                                               Handle class_loader,
303                                               InstanceKlass* k, TRAPS);
304   static InstanceKlass* load_instance_class_impl(Symbol* class_name, Handle class_loader, TRAPS);
305   static InstanceKlass* load_instance_class(Symbol* class_name,
306                                             Handle class_loader, TRAPS);
307 

314                                       PackageEntry* pkg_entry,
315                                       Handle class_loader);
316   static bool is_shared_class_visible_impl(Symbol* class_name,
317                                            InstanceKlass* ik,
318                                            PackageEntry* pkg_entry,
319                                            Handle class_loader);
320   static bool check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super,
321                                             Handle class_loader,
322                                             bool is_superclass, TRAPS);
323   static bool check_shared_class_super_types(InstanceKlass* ik, Handle class_loader, TRAPS);
324   // Second part of load_shared_class
325   static void load_shared_class_misc(InstanceKlass* ik, ClassLoaderData* loader_data) NOT_CDS_RETURN;
326   static void restore_archived_method_handle_intrinsics_impl(TRAPS) NOT_CDS_RETURN;
327 
328 protected:
329   // Used by SystemDictionaryShared and LambdaProxyClassDictionary
330 
331   static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked,  Handle loader1,
332                                     Handle loader2);
333   static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld);


334   static InstanceKlass* load_shared_class(InstanceKlass* ik,
335                                           Handle class_loader,
336                                           Handle protection_domain,
337                                           const ClassFileStream *cfs,
338                                           PackageEntry* pkg_entry,
339                                           TRAPS);
340   static Handle get_loader_lock_or_null(Handle class_loader);
341   static InstanceKlass* find_or_define_instance_class(Symbol* class_name,
342                                                       Handle class_loader,
343                                                       InstanceKlass* k, TRAPS);
344 
345 public:
346   static bool is_system_class_loader(oop class_loader);
347   static bool is_platform_class_loader(oop class_loader);
348   static bool is_boot_class_loader(oop class_loader) { return class_loader == nullptr; }
349   static bool is_builtin_class_loader(oop class_loader) {
350     return is_boot_class_loader(class_loader)      ||
351            is_platform_class_loader(class_loader)  ||
352            is_system_class_loader(class_loader);
353   }

122   // Parse the stream to create a hidden class.
123   // Used by jvm_lookup_define_class.
124   static InstanceKlass* resolve_hidden_class_from_stream(ClassFileStream* st,
125                                                          Symbol* class_name,
126                                                          Handle class_loader,
127                                                          const ClassLoadInfo& cl_info,
128                                                          TRAPS);
129 
130   // Resolve a class from stream (called by jni_DefineClass and JVM_DefineClass)
131   // This class is added to the SystemDictionary.
132   static InstanceKlass* resolve_class_from_stream(ClassFileStream* st,
133                                                   Symbol* class_name,
134                                                   Handle class_loader,
135                                                   const ClassLoadInfo& cl_info,
136                                                   TRAPS);
137 
138   static oop get_system_class_loader_impl(TRAPS);
139   static oop get_platform_class_loader_impl(TRAPS);
140 
141  public:
142 
143   // Resolve either a hidden or normal class from a stream of bytes, based on ClassLoadInfo
144   static InstanceKlass* resolve_from_stream(ClassFileStream* st,
145                                             Symbol* class_name,
146                                             Handle class_loader,
147                                             const ClassLoadInfo& cl_info,
148                                             TRAPS);
149 
150   // Lookup an already loaded class. If not found null is returned.
151   static InstanceKlass* find_instance_klass(Thread* current, Symbol* class_name,
152                                             Handle class_loader);
153 
154   // Lookup an already loaded instance or array class.
155   // Do not make any queries to class loaders; consult only the cache.
156   // If not found null is returned.
157   static Klass* find_instance_or_array_klass(Thread* current, Symbol* class_name,
158                                              Handle class_loader);
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

268 
269   // ask Java to compute a constant by invoking a BSM given a Dynamic_info CP entry
270   static void      invoke_bootstrap_method(BootstrapInfo& bootstrap_specifier, TRAPS);
271 
272   // Record the error when the first attempt to resolve a reference from a constant
273   // pool entry to a class fails.
274   static void add_resolution_error(const constantPoolHandle& pool, int which,
275                                    Symbol* error, const char* message,
276                                    Symbol* cause = nullptr, const char* cause_msg = nullptr);
277   static void delete_resolution_error(ConstantPool* pool);
278   static Symbol* find_resolution_error(const constantPoolHandle& pool, int which,
279                                        const char** message,
280                                        Symbol** cause, const char** cause_msg);
281 
282   // Record a nest host resolution/validation error
283   static void add_nest_host_error(const constantPoolHandle& pool, int which,
284                                   const char* message);
285   static const char* find_nest_host_error(const constantPoolHandle& pool, int which);
286 
287   static void add_to_initiating_loader(JavaThread* current, InstanceKlass* k,
288                                        ClassLoaderData* loader_data);
289 
290   static OopHandle  _java_system_loader;
291   static OopHandle  _java_platform_loader;
292 
293 private:
294   // Basic loading operations
295   static InstanceKlass* resolve_instance_class_or_null(Symbol* class_name,
296                                                        Handle class_loader,
297                                                        TRAPS);
298   static Klass* resolve_array_class_or_null(Symbol* class_name,
299                                             Handle class_loader,
300                                             TRAPS);
301   static void define_instance_class(InstanceKlass* k, Handle class_loader, TRAPS);
302   static InstanceKlass* find_or_define_helper(Symbol* class_name,
303                                               Handle class_loader,
304                                               InstanceKlass* k, TRAPS);
305   static InstanceKlass* load_instance_class_impl(Symbol* class_name, Handle class_loader, TRAPS);
306   static InstanceKlass* load_instance_class(Symbol* class_name,
307                                             Handle class_loader, TRAPS);
308 

315                                       PackageEntry* pkg_entry,
316                                       Handle class_loader);
317   static bool is_shared_class_visible_impl(Symbol* class_name,
318                                            InstanceKlass* ik,
319                                            PackageEntry* pkg_entry,
320                                            Handle class_loader);
321   static bool check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super,
322                                             Handle class_loader,
323                                             bool is_superclass, TRAPS);
324   static bool check_shared_class_super_types(InstanceKlass* ik, Handle class_loader, TRAPS);
325   // Second part of load_shared_class
326   static void load_shared_class_misc(InstanceKlass* ik, ClassLoaderData* loader_data) NOT_CDS_RETURN;
327   static void restore_archived_method_handle_intrinsics_impl(TRAPS) NOT_CDS_RETURN;
328 
329 protected:
330   // Used by SystemDictionaryShared and LambdaProxyClassDictionary
331 
332   static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked,  Handle loader1,
333                                     Handle loader2);
334   static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld);
335   static bool preload_from_null_free_field(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS);
336   static void try_preload_from_loadable_descriptors(InstanceKlass* ik, Handle class_loader, Symbol* sig, int field_index, TRAPS);
337   static InstanceKlass* load_shared_class(InstanceKlass* ik,
338                                           Handle class_loader,
339                                           Handle protection_domain,
340                                           const ClassFileStream *cfs,
341                                           PackageEntry* pkg_entry,
342                                           TRAPS);
343   static Handle get_loader_lock_or_null(Handle class_loader);
344   static InstanceKlass* find_or_define_instance_class(Symbol* class_name,
345                                                       Handle class_loader,
346                                                       InstanceKlass* k, TRAPS);
347 
348 public:
349   static bool is_system_class_loader(oop class_loader);
350   static bool is_platform_class_loader(oop class_loader);
351   static bool is_boot_class_loader(oop class_loader) { return class_loader == nullptr; }
352   static bool is_builtin_class_loader(oop class_loader) {
353     return is_boot_class_loader(class_loader)      ||
354            is_platform_class_loader(class_loader)  ||
355            is_system_class_loader(class_loader);
356   }
< prev index next >