1.1 --- a/src/share/vm/classfile/systemDictionary.hpp Thu Jan 27 13:42:28 2011 -0800
1.2 +++ b/src/share/vm/classfile/systemDictionary.hpp Thu Jan 27 16:11:27 2011 -0800
1.3 @@ -28,14 +28,14 @@
1.4 #include "classfile/classFileStream.hpp"
1.5 #include "classfile/classLoader.hpp"
1.6 #include "oops/objArrayOop.hpp"
1.7 -#include "oops/symbolOop.hpp"
1.8 +#include "oops/symbol.hpp"
1.9 #include "runtime/java.hpp"
1.10 #include "runtime/reflectionUtils.hpp"
1.11 #include "utilities/hashtable.hpp"
1.12
1.13 // The system dictionary stores all loaded classes and maps:
1.14 //
1.15 -// [class name,class loader] -> class i.e. [symbolOop,oop] -> klassOop
1.16 +// [class name,class loader] -> class i.e. [Symbol*,oop] -> klassOop
1.17 //
1.18 // Classes are loaded lazily. The default VM class loader is
1.19 // represented as NULL.
1.20 @@ -226,26 +226,26 @@
1.21 // throw_error flag. For most uses the throw_error argument should be set
1.22 // to true.
1.23
1.24 - static klassOop resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS);
1.25 + static klassOop resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS);
1.26 // Convenient call for null loader and protection domain.
1.27 - static klassOop resolve_or_fail(symbolHandle class_name, bool throw_error, TRAPS);
1.28 + static klassOop resolve_or_fail(Symbol* class_name, bool throw_error, TRAPS);
1.29 private:
1.30 // handle error translation for resolve_or_null results
1.31 - static klassOop handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS);
1.32 + static klassOop handle_resolution_exception(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS);
1.33
1.34 public:
1.35
1.36 // Returns a class with a given class name and class loader.
1.37 // Loads the class if needed. If not found NULL is returned.
1.38 - static klassOop resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.39 + static klassOop resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.40 // Version with null loader and protection domain
1.41 - static klassOop resolve_or_null(symbolHandle class_name, TRAPS);
1.42 + static klassOop resolve_or_null(Symbol* class_name, TRAPS);
1.43
1.44 // Resolve a superclass or superinterface. Called from ClassFileParser,
1.45 // parse_interfaces, resolve_instance_class_or_null, load_shared_class
1.46 // "child_name" is the class whose super class or interface is being resolved.
1.47 - static klassOop resolve_super_or_fail(symbolHandle child_name,
1.48 - symbolHandle class_name,
1.49 + static klassOop resolve_super_or_fail(Symbol* child_name,
1.50 + Symbol* class_name,
1.51 Handle class_loader,
1.52 Handle protection_domain,
1.53 bool is_superclass,
1.54 @@ -253,7 +253,7 @@
1.55
1.56 // Parse new stream. This won't update the system dictionary or
1.57 // class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses.
1.58 - static klassOop parse_stream(symbolHandle class_name,
1.59 + static klassOop parse_stream(Symbol* class_name,
1.60 Handle class_loader,
1.61 Handle protection_domain,
1.62 ClassFileStream* st,
1.63 @@ -261,7 +261,7 @@
1.64 KlassHandle nullHandle;
1.65 return parse_stream(class_name, class_loader, protection_domain, st, nullHandle, NULL, THREAD);
1.66 }
1.67 - static klassOop parse_stream(symbolHandle class_name,
1.68 + static klassOop parse_stream(Symbol* class_name,
1.69 Handle class_loader,
1.70 Handle protection_domain,
1.71 ClassFileStream* st,
1.72 @@ -270,23 +270,23 @@
1.73 TRAPS);
1.74
1.75 // Resolve from stream (called by jni_DefineClass and JVM_DefineClass)
1.76 - static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader,
1.77 + static klassOop resolve_from_stream(Symbol* class_name, Handle class_loader,
1.78 Handle protection_domain,
1.79 ClassFileStream* st, bool verify, TRAPS);
1.80
1.81 // Lookup an already loaded class. If not found NULL is returned.
1.82 - static klassOop find(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.83 + static klassOop find(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.84
1.85 // Lookup an already loaded instance or array class.
1.86 // Do not make any queries to class loaders; consult only the cache.
1.87 // If not found NULL is returned.
1.88 - static klassOop find_instance_or_array_klass(symbolHandle class_name,
1.89 + static klassOop find_instance_or_array_klass(Symbol* class_name,
1.90 Handle class_loader,
1.91 Handle protection_domain,
1.92 TRAPS);
1.93
1.94 // If the given name is known to vmSymbols, return the well-know klass:
1.95 - static klassOop find_well_known_klass(symbolOop class_name);
1.96 + static klassOop find_well_known_klass(Symbol* class_name);
1.97
1.98 // Lookup an instance or array class that has already been loaded
1.99 // either into the given class loader, or else into another class
1.100 @@ -309,7 +309,7 @@
1.101 // satisfied, and it is safe for classes in the given class loader
1.102 // to manipulate strongly-typed values of the found class, subject
1.103 // to local linkage and access checks.
1.104 - static klassOop find_constrained_instance_or_array_klass(symbolHandle class_name,
1.105 + static klassOop find_constrained_instance_or_array_klass(Symbol* class_name,
1.106 Handle class_loader,
1.107 TRAPS);
1.108
1.109 @@ -324,7 +324,7 @@
1.110 // (added for helpers that use HandleMarks and ResourceMarks)
1.111 static void classes_do(void f(klassOop, oop, TRAPS), TRAPS);
1.112 // All entries in the placeholder table and their class loaders
1.113 - static void placeholders_do(void f(symbolOop, oop));
1.114 + static void placeholders_do(void f(Symbol*, oop));
1.115
1.116 // Iterate over all methods in all klasses in dictionary
1.117 static void methods_do(void f(methodOop));
1.118 @@ -383,12 +383,12 @@
1.119 static void verify();
1.120
1.121 #ifdef ASSERT
1.122 - static bool is_internal_format(symbolHandle class_name);
1.123 + static bool is_internal_format(Symbol* class_name);
1.124 #endif
1.125
1.126 // Verify class is in dictionary
1.127 static void verify_obj_klass_present(Handle obj,
1.128 - symbolHandle class_name,
1.129 + Symbol* class_name,
1.130 Handle class_loader);
1.131
1.132 // Initialization
1.133 @@ -469,19 +469,19 @@
1.134 // Note: java_lang_Class::primitive_type is the inverse of java_mirror
1.135
1.136 // Check class loader constraints
1.137 - static bool add_loader_constraint(symbolHandle name, Handle loader1,
1.138 + static bool add_loader_constraint(Symbol* name, Handle loader1,
1.139 Handle loader2, TRAPS);
1.140 - static char* check_signature_loaders(symbolHandle signature, Handle loader1,
1.141 + static char* check_signature_loaders(Symbol* signature, Handle loader1,
1.142 Handle loader2, bool is_method, TRAPS);
1.143
1.144 // JSR 292
1.145 // find the java.dyn.MethodHandles::invoke method for a given signature
1.146 - static methodOop find_method_handle_invoke(symbolHandle name,
1.147 - symbolHandle signature,
1.148 + static methodOop find_method_handle_invoke(Symbol* name,
1.149 + Symbol* signature,
1.150 KlassHandle accessing_klass,
1.151 TRAPS);
1.152 // ask Java to compute a java.dyn.MethodType object for a given signature
1.153 - static Handle find_method_handle_type(symbolHandle signature,
1.154 + static Handle find_method_handle_type(Symbol* signature,
1.155 KlassHandle accessing_klass,
1.156 bool for_invokeGeneric,
1.157 bool& return_bcp_flag,
1.158 @@ -490,13 +490,13 @@
1.159 static Handle link_method_handle_constant(KlassHandle caller,
1.160 int ref_kind, //e.g., JVM_REF_invokeVirtual
1.161 KlassHandle callee,
1.162 - symbolHandle name,
1.163 - symbolHandle signature,
1.164 + Symbol* name,
1.165 + Symbol* signature,
1.166 TRAPS);
1.167 // ask Java to create a dynamic call site, while linking an invokedynamic op
1.168 static Handle make_dynamic_call_site(Handle bootstrap_method,
1.169 // Callee information:
1.170 - symbolHandle name,
1.171 + Symbol* name,
1.172 methodHandle signature_invoker,
1.173 Handle info,
1.174 // Caller information:
1.175 @@ -519,8 +519,8 @@
1.176
1.177 // Record the error when the first attempt to resolve a reference from a constant
1.178 // pool entry to a class fails.
1.179 - static void add_resolution_error(constantPoolHandle pool, int which, symbolHandle error);
1.180 - static symbolOop find_resolution_error(constantPoolHandle pool, int which);
1.181 + static void add_resolution_error(constantPoolHandle pool, int which, Symbol* error);
1.182 + static Symbol* find_resolution_error(constantPoolHandle pool, int which);
1.183
1.184 private:
1.185
1.186 @@ -580,29 +580,29 @@
1.187 static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; }
1.188
1.189 // Basic loading operations
1.190 - static klassOop resolve_instance_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.191 - static klassOop resolve_array_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.192 - static instanceKlassHandle handle_parallel_super_load(symbolHandle class_name, symbolHandle supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS);
1.193 + static klassOop resolve_instance_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.194 + static klassOop resolve_array_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS);
1.195 + static instanceKlassHandle handle_parallel_super_load(Symbol* class_name, Symbol* supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS);
1.196 // Wait on SystemDictionary_lock; unlocks lockObject before
1.197 // waiting; relocks lockObject with correct recursion count
1.198 // after waiting, but before reentering SystemDictionary_lock
1.199 // to preserve lock order semantics.
1.200 static void double_lock_wait(Handle lockObject, TRAPS);
1.201 static void define_instance_class(instanceKlassHandle k, TRAPS);
1.202 - static instanceKlassHandle find_or_define_instance_class(symbolHandle class_name,
1.203 + static instanceKlassHandle find_or_define_instance_class(Symbol* class_name,
1.204 Handle class_loader,
1.205 instanceKlassHandle k, TRAPS);
1.206 - static instanceKlassHandle load_shared_class(symbolHandle class_name,
1.207 + static instanceKlassHandle load_shared_class(Symbol* class_name,
1.208 Handle class_loader, TRAPS);
1.209 static instanceKlassHandle load_shared_class(instanceKlassHandle ik,
1.210 Handle class_loader, TRAPS);
1.211 - static instanceKlassHandle load_instance_class(symbolHandle class_name, Handle class_loader, TRAPS);
1.212 + static instanceKlassHandle load_instance_class(Symbol* class_name, Handle class_loader, TRAPS);
1.213 static Handle compute_loader_lock_object(Handle class_loader, TRAPS);
1.214 static void check_loader_lock_contention(Handle loader_lock, TRAPS);
1.215 static bool is_parallelCapable(Handle class_loader);
1.216 static bool is_parallelDefine(Handle class_loader);
1.217
1.218 - static klassOop find_shared_class(symbolHandle class_name);
1.219 + static klassOop find_shared_class(Symbol* class_name);
1.220
1.221 // Setup link to hierarchy
1.222 static void add_to_hierarchy(instanceKlassHandle k, TRAPS);
1.223 @@ -613,34 +613,29 @@
1.224
1.225 // Basic find on loaded classes
1.226 static klassOop find_class(int index, unsigned int hash,
1.227 - symbolHandle name, Handle loader);
1.228 + Symbol* name, Handle loader);
1.229 + static klassOop find_class(Symbol* class_name, Handle class_loader);
1.230
1.231 // Basic find on classes in the midst of being loaded
1.232 - static symbolOop find_placeholder(int index, unsigned int hash,
1.233 - symbolHandle name, Handle loader);
1.234 -
1.235 - // Basic find operation of loaded classes and classes in the midst
1.236 - // of loading; used for assertions and verification only.
1.237 - static oop find_class_or_placeholder(symbolHandle class_name,
1.238 - Handle class_loader);
1.239 + static Symbol* find_placeholder(Symbol* name, Handle loader);
1.240
1.241 // Updating entry in dictionary
1.242 // Add a completely loaded class
1.243 - static void add_klass(int index, symbolHandle class_name,
1.244 + static void add_klass(int index, Symbol* class_name,
1.245 Handle class_loader, KlassHandle obj);
1.246
1.247 // Add a placeholder for a class being loaded
1.248 static void add_placeholder(int index,
1.249 - symbolHandle class_name,
1.250 + Symbol* class_name,
1.251 Handle class_loader);
1.252 static void remove_placeholder(int index,
1.253 - symbolHandle class_name,
1.254 + Symbol* class_name,
1.255 Handle class_loader);
1.256
1.257 // Performs cleanups after resolve_super_or_fail. This typically needs
1.258 // to be called on failure.
1.259 // Won't throw, but can block.
1.260 - static void resolution_cleanups(symbolHandle class_name,
1.261 + static void resolution_cleanups(Symbol* class_name,
1.262 Handle class_loader,
1.263 TRAPS);
1.264
1.265 @@ -670,7 +665,6 @@
1.266 static bool _has_checkPackageAccess;
1.267 };
1.268
1.269 -// Cf. vmSymbols vs. vmSymbolHandles
1.270 class SystemDictionaryHandles : AllStatic {
1.271 public:
1.272 #define WK_KLASS_HANDLE_DECLARE(name, ignore_symbol, option) \
