diff -r 6061df52d610 -r 53ccc37bda19 hotspot/src/share/vm/classfile/systemDictionary.hpp --- a/hotspot/src/share/vm/classfile/systemDictionary.hpp Wed Mar 15 11:44:46 2017 +0100 +++ b/hotspot/src/share/vm/classfile/systemDictionary.hpp Wed Mar 15 10:25:37 2017 -0400 @@ -259,7 +259,7 @@ static Klass* resolve_or_fail(Symbol* class_name, bool throw_error, TRAPS); protected: // handle error translation for resolve_or_null results - static Klass* handle_resolution_exception(Symbol* class_name, bool throw_error, KlassHandle klass_h, TRAPS); + static Klass* handle_resolution_exception(Symbol* class_name, bool throw_error, Klass* klass, TRAPS); public: @@ -282,11 +282,11 @@ // Parse new stream. This won't update the system dictionary or // class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses. // Also used by Unsafe_DefineAnonymousClass - static Klass* parse_stream(Symbol* class_name, - Handle class_loader, - Handle protection_domain, - ClassFileStream* st, - TRAPS) { + static InstanceKlass* parse_stream(Symbol* class_name, + Handle class_loader, + Handle protection_domain, + ClassFileStream* st, + TRAPS) { return parse_stream(class_name, class_loader, protection_domain, @@ -295,20 +295,20 @@ NULL, // cp_patches THREAD); } - static Klass* parse_stream(Symbol* class_name, - Handle class_loader, - Handle protection_domain, - ClassFileStream* st, - const InstanceKlass* host_klass, - GrowableArray* cp_patches, - TRAPS); + static InstanceKlass* parse_stream(Symbol* class_name, + Handle class_loader, + Handle protection_domain, + ClassFileStream* st, + const InstanceKlass* host_klass, + GrowableArray* cp_patches, + TRAPS); // Resolve from stream (called by jni_DefineClass and JVM_DefineClass) - static Klass* resolve_from_stream(Symbol* class_name, - Handle class_loader, - Handle protection_domain, - ClassFileStream* st, - TRAPS); + static InstanceKlass* resolve_from_stream(Symbol* class_name, + Handle class_loader, + Handle protection_domain, + ClassFileStream* st, + TRAPS); // Lookup an already loaded class. If not found NULL is returned. static Klass* find(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); @@ -516,10 +516,10 @@ // JSR 292 // find a java.lang.invoke.MethodHandle.invoke* method for a given signature // (asks Java to compute it if necessary, except in a compiler thread) - static methodHandle find_method_handle_invoker(KlassHandle klass, + static methodHandle find_method_handle_invoker(Klass* klass, Symbol* name, Symbol* signature, - KlassHandle accessing_klass, + Klass* accessing_klass, Handle *appendix_result, Handle *method_type_result, TRAPS); @@ -531,19 +531,19 @@ // find a java.lang.invoke.MethodType object for a given signature // (asks Java to compute it if necessary, except in a compiler thread) static Handle find_method_handle_type(Symbol* signature, - KlassHandle accessing_klass, + Klass* accessing_klass, TRAPS); // ask Java to compute a java.lang.invoke.MethodHandle object for a given CP entry - static Handle link_method_handle_constant(KlassHandle caller, + static Handle link_method_handle_constant(Klass* caller, int ref_kind, //e.g., JVM_REF_invokeVirtual - KlassHandle callee, + Klass* callee, Symbol* name, Symbol* signature, TRAPS); // ask Java to create a dynamic call site, while linking an invokedynamic op - static methodHandle find_dynamic_call_site_invoker(KlassHandle caller, + static methodHandle find_dynamic_call_site_invoker(Klass* caller, Handle bootstrap_method, Symbol* name, Symbol* type, @@ -615,7 +615,7 @@ static Klass* try_get_next_class(); protected: - static void validate_protection_domain(instanceKlassHandle klass, + static void validate_protection_domain(InstanceKlass* klass, Handle class_loader, Handle protection_domain, TRAPS); @@ -631,48 +631,48 @@ // Basic loading operations static Klass* resolve_instance_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); static Klass* resolve_array_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); - static instanceKlassHandle handle_parallel_super_load(Symbol* class_name, Symbol* supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS); + static InstanceKlass* handle_parallel_super_load(Symbol* class_name, Symbol* supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS); // Wait on SystemDictionary_lock; unlocks lockObject before // waiting; relocks lockObject with correct recursion count // after waiting, but before reentering SystemDictionary_lock // to preserve lock order semantics. static void double_lock_wait(Handle lockObject, TRAPS); - static void define_instance_class(instanceKlassHandle k, TRAPS); - static instanceKlassHandle find_or_define_instance_class(Symbol* class_name, + static void define_instance_class(InstanceKlass* k, TRAPS); + static InstanceKlass* find_or_define_instance_class(Symbol* class_name, Handle class_loader, - instanceKlassHandle k, TRAPS); - static bool is_shared_class_visible(Symbol* class_name, instanceKlassHandle ik, + InstanceKlass* k, TRAPS); + static bool is_shared_class_visible(Symbol* class_name, InstanceKlass* ik, Handle class_loader, TRAPS); - static instanceKlassHandle load_shared_class(instanceKlassHandle ik, - Handle class_loader, - Handle protection_domain, - TRAPS); - static instanceKlassHandle load_instance_class(Symbol* class_name, Handle class_loader, TRAPS); + static InstanceKlass* load_shared_class(InstanceKlass* ik, + Handle class_loader, + Handle protection_domain, + TRAPS); + static InstanceKlass* load_instance_class(Symbol* class_name, Handle class_loader, TRAPS); static Handle compute_loader_lock_object(Handle class_loader, TRAPS); static void check_loader_lock_contention(Handle loader_lock, TRAPS); static bool is_parallelCapable(Handle class_loader); static bool is_parallelDefine(Handle class_loader); public: - static instanceKlassHandle load_shared_class(Symbol* class_name, - Handle class_loader, - TRAPS); + static InstanceKlass* load_shared_class(Symbol* class_name, + Handle class_loader, + TRAPS); static bool is_system_class_loader(oop class_loader); static bool is_platform_class_loader(oop class_loader); protected: - static Klass* find_shared_class(Symbol* class_name); + static InstanceKlass* find_shared_class(Symbol* class_name); // Setup link to hierarchy - static void add_to_hierarchy(instanceKlassHandle k, TRAPS); + static void add_to_hierarchy(InstanceKlass* k, TRAPS); // We pass in the hashtable index so we can calculate it outside of // the SystemDictionary_lock. // Basic find on loaded classes - static Klass* find_class(int index, unsigned int hash, - Symbol* name, ClassLoaderData* loader_data); - static Klass* find_class(Symbol* class_name, ClassLoaderData* loader_data); + static InstanceKlass* find_class(int index, unsigned int hash, + Symbol* name, ClassLoaderData* loader_data); + static InstanceKlass* find_class(Symbol* class_name, ClassLoaderData* loader_data); // Basic find on classes in the midst of being loaded static Symbol* find_placeholder(Symbol* name, ClassLoaderData* loader_data); @@ -697,11 +697,11 @@ // Class loader constraints static void check_constraints(int index, unsigned int hash, - instanceKlassHandle k, Handle loader, + InstanceKlass* k, Handle loader, bool defining, TRAPS); static void update_dictionary(int d_index, unsigned int d_hash, int p_index, unsigned int p_hash, - instanceKlassHandle k, Handle loader, + InstanceKlass* k, Handle loader, TRAPS); // Variables holding commonly used klasses (preloaded)