< prev index next >
src/share/vm/classfile/systemDictionary.hpp
Print this page
@@ -257,11 +257,11 @@
static Klass* resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS);
// Convenient call for null loader and protection domain.
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:
// Returns a class with a given class name and class loader.
// Loads the class if needed. If not found NULL is returned.
@@ -280,11 +280,11 @@
TRAPS);
// 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,
+ static InstanceKlass* parse_stream(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
TRAPS) {
return parse_stream(class_name,
@@ -293,20 +293,20 @@
st,
NULL, // host klass
NULL, // cp_patches
THREAD);
}
- static Klass* parse_stream(Symbol* class_name,
+ static InstanceKlass* parse_stream(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
const InstanceKlass* host_klass,
GrowableArray<Handle>* cp_patches,
TRAPS);
// Resolve from stream (called by jni_DefineClass and JVM_DefineClass)
- static Klass* resolve_from_stream(Symbol* class_name,
+ static InstanceKlass* resolve_from_stream(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
TRAPS);
@@ -514,14 +514,14 @@
Handle loader2, bool is_method, TRAPS);
// 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);
// for a given signature, find the internal MethodHandle method (linkTo* or invokeBasic)
// (does not ask Java, since this is a low-level intrinsic defined by the JVM)
@@ -529,23 +529,23 @@
Symbol* signature,
TRAPS);
// 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,
Handle *appendix_result,
Handle *method_type_result,
@@ -613,11 +613,11 @@
// for VM_CounterDecay iteration support
friend class CounterDecay;
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);
friend class VM_PopulateDumpSharedSpace;
friend class TraversePlaceholdersClosure;
@@ -629,52 +629,52 @@
static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; }
// 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,
+ static InstanceKlass* load_shared_class(InstanceKlass* ik,
Handle class_loader,
Handle protection_domain,
TRAPS);
- static instanceKlassHandle load_instance_class(Symbol* class_name, Handle class_loader, 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,
+ 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,
+ static InstanceKlass* 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(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);
// Add a placeholder for a class being loaded
@@ -695,15 +695,15 @@
// Initialization
static void initialize_preloaded_classes(TRAPS);
// 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)
static InstanceKlass* _well_known_klasses[];
< prev index next >