author | twisti |
Mon, 04 Jan 2010 18:38:08 +0100 | |
changeset 4564 | 55dfb20908d0 |
parent 4452 | 9b27d522a642 |
child 4571 | 80b553bddc26 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
2105 | 2 |
* Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. |
1 | 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 |
* have any questions. |
|
22 |
* |
|
23 |
*/ |
|
24 |
||
25 |
// The system dictionary stores all loaded classes and maps: |
|
26 |
// |
|
27 |
// [class name,class loader] -> class i.e. [symbolOop,oop] -> klassOop |
|
28 |
// |
|
29 |
// Classes are loaded lazily. The default VM class loader is |
|
30 |
// represented as NULL. |
|
31 |
||
32 |
// The underlying data structure is an open hash table with a fixed number |
|
33 |
// of buckets. During loading the loader object is locked, (for the VM loader |
|
34 |
// a private lock object is used). Class loading can thus be done concurrently, |
|
35 |
// but only by different loaders. |
|
36 |
// |
|
37 |
// During loading a placeholder (name, loader) is temporarily placed in |
|
38 |
// a side data structure, and is used to detect ClassCircularityErrors |
|
39 |
// and to perform verification during GC. A GC can occur in the midst |
|
40 |
// of class loading, as we call out to Java, have to take locks, etc. |
|
41 |
// |
|
42 |
// When class loading is finished, a new entry is added to the system |
|
43 |
// dictionary and the place holder is removed. Note that the protection |
|
44 |
// domain field of the system dictionary has not yet been filled in when |
|
45 |
// the "real" system dictionary entry is created. |
|
46 |
// |
|
47 |
// Clients of this class who are interested in finding if a class has |
|
48 |
// been completely loaded -- not classes in the process of being loaded -- |
|
49 |
// can read the SystemDictionary unlocked. This is safe because |
|
50 |
// - entries are only deleted at safepoints |
|
51 |
// - readers cannot come to a safepoint while actively examining |
|
52 |
// an entry (an entry cannot be deleted from under a reader) |
|
53 |
// - entries must be fully formed before they are available to concurrent |
|
54 |
// readers (we must ensure write ordering) |
|
55 |
// |
|
56 |
// Note that placeholders are deleted at any time, as they are removed |
|
57 |
// when a class is completely loaded. Therefore, readers as well as writers |
|
58 |
// of placeholders must hold the SystemDictionary_lock. |
|
59 |
// |
|
60 |
||
61 |
class Dictionary; |
|
62 |
class PlaceholderTable; |
|
63 |
class LoaderConstraintTable; |
|
64 |
class HashtableBucket; |
|
65 |
class ResolutionErrorTable; |
|
2534 | 66 |
class SymbolPropertyTable; |
1 | 67 |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
68 |
// Certain classes are preloaded, such as java.lang.Object and java.lang.String. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
69 |
// They are all "well-known", in the sense that no class loader is allowed |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
70 |
// to provide a different definition. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
71 |
// |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
72 |
// These klasses must all have names defined in vmSymbols. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
73 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
74 |
#define WK_KLASS_ENUM_NAME(kname) kname##_knum |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
75 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
76 |
// Each well-known class has a short klass name (like object_klass), |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
77 |
// a vmSymbol name (like java_lang_Object), and a flag word |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
78 |
// that makes some minor distinctions, like whether the klass |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
79 |
// is preloaded, optional, release-specific, etc. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
80 |
// The order of these definitions is significant; it is the order in which |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
81 |
// preloading is actually performed by initialize_preloaded_classes. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
82 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
83 |
#define WK_KLASSES_DO(template) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
84 |
/* well-known classes */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
85 |
template(object_klass, java_lang_Object, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
86 |
template(string_klass, java_lang_String, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
87 |
template(class_klass, java_lang_Class, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
88 |
template(cloneable_klass, java_lang_Cloneable, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
89 |
template(classloader_klass, java_lang_ClassLoader, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
90 |
template(serializable_klass, java_io_Serializable, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
91 |
template(system_klass, java_lang_System, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
92 |
template(throwable_klass, java_lang_Throwable, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
93 |
template(error_klass, java_lang_Error, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
94 |
template(threaddeath_klass, java_lang_ThreadDeath, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
95 |
template(exception_klass, java_lang_Exception, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
96 |
template(runtime_exception_klass, java_lang_RuntimeException, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
97 |
template(protectionDomain_klass, java_security_ProtectionDomain, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
98 |
template(AccessControlContext_klass, java_security_AccessControlContext, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
99 |
template(classNotFoundException_klass, java_lang_ClassNotFoundException, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
100 |
template(noClassDefFoundError_klass, java_lang_NoClassDefFoundError, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
101 |
template(linkageError_klass, java_lang_LinkageError, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
102 |
template(ClassCastException_klass, java_lang_ClassCastException, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
103 |
template(ArrayStoreException_klass, java_lang_ArrayStoreException, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
104 |
template(virtualMachineError_klass, java_lang_VirtualMachineError, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
105 |
template(OutOfMemoryError_klass, java_lang_OutOfMemoryError, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
106 |
template(StackOverflowError_klass, java_lang_StackOverflowError, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
107 |
template(IllegalMonitorStateException_klass, java_lang_IllegalMonitorStateException, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
108 |
template(reference_klass, java_lang_ref_Reference, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
109 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
110 |
/* Preload ref klasses and set reference types */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
111 |
template(soft_reference_klass, java_lang_ref_SoftReference, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
112 |
template(weak_reference_klass, java_lang_ref_WeakReference, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
113 |
template(final_reference_klass, java_lang_ref_FinalReference, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
114 |
template(phantom_reference_klass, java_lang_ref_PhantomReference, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
115 |
template(finalizer_klass, java_lang_ref_Finalizer, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
116 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
117 |
template(thread_klass, java_lang_Thread, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
118 |
template(threadGroup_klass, java_lang_ThreadGroup, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
119 |
template(properties_klass, java_util_Properties, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
120 |
template(reflect_accessible_object_klass, java_lang_reflect_AccessibleObject, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
121 |
template(reflect_field_klass, java_lang_reflect_Field, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
122 |
template(reflect_method_klass, java_lang_reflect_Method, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
123 |
template(reflect_constructor_klass, java_lang_reflect_Constructor, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
124 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
125 |
/* NOTE: needed too early in bootstrapping process to have checks based on JDK version */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
126 |
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
127 |
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
128 |
template(reflect_magic_klass, sun_reflect_MagicAccessorImpl, Opt) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
129 |
template(reflect_method_accessor_klass, sun_reflect_MethodAccessorImpl, Opt_Only_JDK14NewRef) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
130 |
template(reflect_constructor_accessor_klass, sun_reflect_ConstructorAccessorImpl, Opt_Only_JDK14NewRef) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
131 |
template(reflect_delegating_classloader_klass, sun_reflect_DelegatingClassLoader, Opt) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
132 |
template(reflect_constant_pool_klass, sun_reflect_ConstantPool, Opt_Only_JDK15) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
133 |
template(reflect_unsafe_static_field_accessor_impl_klass, sun_reflect_UnsafeStaticFieldAccessorImpl, Opt_Only_JDK15) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
134 |
\ |
2534 | 135 |
/* support for dynamic typing; it's OK if these are NULL in earlier JDKs */ \ |
136 |
template(MethodHandle_klass, java_dyn_MethodHandle, Opt) \ |
|
137 |
template(MemberName_klass, sun_dyn_MemberName, Opt) \ |
|
138 |
template(MethodHandleImpl_klass, sun_dyn_MethodHandleImpl, Opt) \ |
|
139 |
template(AdapterMethodHandle_klass, sun_dyn_AdapterMethodHandle, Opt) \ |
|
140 |
template(BoundMethodHandle_klass, sun_dyn_BoundMethodHandle, Opt) \ |
|
141 |
template(DirectMethodHandle_klass, sun_dyn_DirectMethodHandle, Opt) \ |
|
142 |
template(MethodType_klass, java_dyn_MethodType, Opt) \ |
|
143 |
template(MethodTypeForm_klass, java_dyn_MethodTypeForm, Opt) \ |
|
144 |
template(WrongMethodTypeException_klass, java_dyn_WrongMethodTypeException, Opt) \ |
|
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
145 |
template(Linkage_klass, java_dyn_Linkage, Opt) \ |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
146 |
template(CallSite_klass, java_dyn_CallSite, Opt) \ |
4564
55dfb20908d0
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
4452
diff
changeset
|
147 |
template(InvokeDynamic_klass, java_dyn_InvokeDynamic, Opt) \ |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
148 |
/* Note: MethodHandle must be first, and Dynamic last in group */ \ |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
149 |
\ |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
150 |
template(vector_klass, java_util_Vector, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
151 |
template(hashtable_klass, java_util_Hashtable, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
152 |
template(stringBuffer_klass, java_lang_StringBuffer, Pre) \ |
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
4429
diff
changeset
|
153 |
template(StringBuilder_klass, java_lang_StringBuilder, Pre) \ |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
154 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
155 |
/* It's NULL in non-1.4 JDKs. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
156 |
template(stackTraceElement_klass, java_lang_StackTraceElement, Opt) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
157 |
/* Universe::is_gte_jdk14x_version() is not set up by this point. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
158 |
/* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
159 |
template(java_nio_Buffer_klass, java_nio_Buffer, Opt) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
160 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
161 |
/* If this class isn't present, it won't be referenced. */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
162 |
template(sun_misc_AtomicLongCSImpl_klass, sun_misc_AtomicLongCSImpl, Opt) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
163 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
164 |
template(sun_jkernel_DownloadManager_klass, sun_jkernel_DownloadManager, Opt_Kernel) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
165 |
\ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
166 |
/* Preload boxing klasses */ \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
167 |
template(boolean_klass, java_lang_Boolean, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
168 |
template(char_klass, java_lang_Character, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
169 |
template(float_klass, java_lang_Float, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
170 |
template(double_klass, java_lang_Double, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
171 |
template(byte_klass, java_lang_Byte, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
172 |
template(short_klass, java_lang_Short, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
173 |
template(int_klass, java_lang_Integer, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
174 |
template(long_klass, java_lang_Long, Pre) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
175 |
/*end*/ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
176 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
177 |
|
1 | 178 |
class SystemDictionary : AllStatic { |
179 |
friend class VMStructs; |
|
180 |
friend class CompactingPermGenGen; |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
181 |
friend class SystemDictionaryHandles; |
1 | 182 |
NOT_PRODUCT(friend class instanceKlassKlass;) |
183 |
||
184 |
public: |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
185 |
enum WKID { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
186 |
NO_WKID = 0, |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
187 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
188 |
#define WK_KLASS_ENUM(name, ignore_s, ignore_o) WK_KLASS_ENUM_NAME(name), |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
189 |
WK_KLASSES_DO(WK_KLASS_ENUM) |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
190 |
#undef WK_KLASS_ENUM |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
191 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
192 |
WKID_LIMIT, |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
193 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
194 |
FIRST_WKID = NO_WKID + 1 |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
195 |
}; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
196 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
197 |
enum InitOption { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
198 |
Pre, // preloaded; error if not present |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
199 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
200 |
// Order is significant. Options before this point require resolve_or_fail. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
201 |
// Options after this point will use resolve_or_null instead. |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
202 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
203 |
Opt, // preload tried; NULL if not present |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
204 |
Opt_Only_JDK14NewRef, // preload tried; use only with NewReflection |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
205 |
Opt_Only_JDK15, // preload tried; use only with JDK1.5+ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
206 |
Opt_Kernel, // preload tried only #ifdef KERNEL |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
207 |
OPTION_LIMIT, |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
208 |
CEIL_LG_OPTION_LIMIT = 4 // OPTION_LIMIT <= (1<<CEIL_LG_OPTION_LIMIT) |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
209 |
}; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
210 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
211 |
|
1 | 212 |
// Returns a class with a given class name and class loader. Loads the |
213 |
// class if needed. If not found a NoClassDefFoundError or a |
|
214 |
// ClassNotFoundException is thrown, depending on the value on the |
|
215 |
// throw_error flag. For most uses the throw_error argument should be set |
|
216 |
// to true. |
|
217 |
||
218 |
static klassOop resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS); |
|
219 |
// Convenient call for null loader and protection domain. |
|
220 |
static klassOop resolve_or_fail(symbolHandle class_name, bool throw_error, TRAPS); |
|
221 |
private: |
|
222 |
// handle error translation for resolve_or_null results |
|
223 |
static klassOop handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS); |
|
224 |
||
225 |
public: |
|
226 |
||
227 |
// Returns a class with a given class name and class loader. |
|
228 |
// Loads the class if needed. If not found NULL is returned. |
|
229 |
static klassOop resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
230 |
// Version with null loader and protection domain |
|
231 |
static klassOop resolve_or_null(symbolHandle class_name, TRAPS); |
|
232 |
||
233 |
// Resolve a superclass or superinterface. Called from ClassFileParser, |
|
234 |
// parse_interfaces, resolve_instance_class_or_null, load_shared_class |
|
235 |
// "child_name" is the class whose super class or interface is being resolved. |
|
236 |
static klassOop resolve_super_or_fail(symbolHandle child_name, |
|
237 |
symbolHandle class_name, |
|
238 |
Handle class_loader, |
|
239 |
Handle protection_domain, |
|
240 |
bool is_superclass, |
|
241 |
TRAPS); |
|
242 |
||
243 |
// Parse new stream. This won't update the system dictionary or |
|
244 |
// class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses. |
|
245 |
static klassOop parse_stream(symbolHandle class_name, |
|
246 |
Handle class_loader, |
|
247 |
Handle protection_domain, |
|
248 |
ClassFileStream* st, |
|
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
249 |
TRAPS) { |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
250 |
KlassHandle nullHandle; |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
251 |
return parse_stream(class_name, class_loader, protection_domain, st, nullHandle, NULL, THREAD); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
252 |
} |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
253 |
static klassOop parse_stream(symbolHandle class_name, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
254 |
Handle class_loader, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
255 |
Handle protection_domain, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
256 |
ClassFileStream* st, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
257 |
KlassHandle host_klass, |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
258 |
GrowableArray<Handle>* cp_patches, |
1 | 259 |
TRAPS); |
260 |
||
261 |
// Resolve from stream (called by jni_DefineClass and JVM_DefineClass) |
|
3820
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
2570
diff
changeset
|
262 |
static klassOop resolve_from_stream(symbolHandle class_name, Handle class_loader, |
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
2570
diff
changeset
|
263 |
Handle protection_domain, |
0a8fbbe180db
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
2570
diff
changeset
|
264 |
ClassFileStream* st, bool verify, TRAPS); |
1 | 265 |
|
266 |
// Lookup an already loaded class. If not found NULL is returned. |
|
267 |
static klassOop find(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
268 |
||
269 |
// Lookup an already loaded instance or array class. |
|
270 |
// Do not make any queries to class loaders; consult only the cache. |
|
271 |
// If not found NULL is returned. |
|
272 |
static klassOop find_instance_or_array_klass(symbolHandle class_name, |
|
273 |
Handle class_loader, |
|
274 |
Handle protection_domain, |
|
275 |
TRAPS); |
|
276 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
277 |
// If the given name is known to vmSymbols, return the well-know klass: |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
278 |
static klassOop find_well_known_klass(symbolOop class_name); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
279 |
|
1 | 280 |
// Lookup an instance or array class that has already been loaded |
281 |
// either into the given class loader, or else into another class |
|
282 |
// loader that is constrained (via loader constraints) to produce |
|
283 |
// a consistent class. Do not take protection domains into account. |
|
284 |
// Do not make any queries to class loaders; consult only the cache. |
|
285 |
// Return NULL if the class is not found. |
|
286 |
// |
|
287 |
// This function is a strict superset of find_instance_or_array_klass. |
|
288 |
// This function (the unchecked version) makes a conservative prediction |
|
289 |
// of the result of the checked version, assuming successful lookup. |
|
290 |
// If both functions return non-null, they must return the same value. |
|
291 |
// Also, the unchecked version may sometimes be non-null where the |
|
292 |
// checked version is null. This can occur in several ways: |
|
293 |
// 1. No query has yet been made to the class loader. |
|
294 |
// 2. The class loader was queried, but chose not to delegate. |
|
295 |
// 3. ClassLoader.checkPackageAccess rejected a proposed protection domain. |
|
296 |
// 4. Loading was attempted, but there was a linkage error of some sort. |
|
297 |
// In all of these cases, the loader constraints on this type are |
|
298 |
// satisfied, and it is safe for classes in the given class loader |
|
299 |
// to manipulate strongly-typed values of the found class, subject |
|
300 |
// to local linkage and access checks. |
|
301 |
static klassOop find_constrained_instance_or_array_klass(symbolHandle class_name, |
|
302 |
Handle class_loader, |
|
303 |
TRAPS); |
|
304 |
||
305 |
// Iterate over all klasses in dictionary |
|
306 |
// Just the classes from defining class loaders |
|
307 |
static void classes_do(void f(klassOop)); |
|
308 |
// Added for initialize_itable_for_klass to handle exceptions |
|
309 |
static void classes_do(void f(klassOop, TRAPS), TRAPS); |
|
310 |
// All classes, and their class loaders |
|
311 |
static void classes_do(void f(klassOop, oop)); |
|
312 |
// All classes, and their class loaders |
|
313 |
// (added for helpers that use HandleMarks and ResourceMarks) |
|
314 |
static void classes_do(void f(klassOop, oop, TRAPS), TRAPS); |
|
315 |
// All entries in the placeholder table and their class loaders |
|
316 |
static void placeholders_do(void f(symbolOop, oop)); |
|
317 |
||
318 |
// Iterate over all methods in all klasses in dictionary |
|
319 |
static void methods_do(void f(methodOop)); |
|
320 |
||
321 |
// Garbage collection support |
|
322 |
||
323 |
// This method applies "blk->do_oop" to all the pointers to "system" |
|
324 |
// classes and loaders. |
|
325 |
static void always_strong_oops_do(OopClosure* blk); |
|
326 |
static void always_strong_classes_do(OopClosure* blk); |
|
327 |
// This method applies "blk->do_oop" to all the placeholders. |
|
328 |
static void placeholders_do(OopClosure* blk); |
|
329 |
||
330 |
// Unload (that is, break root links to) all unmarked classes and |
|
331 |
// loaders. Returns "true" iff something was unloaded. |
|
332 |
static bool do_unloading(BoolObjectClosure* is_alive); |
|
333 |
||
334 |
// Applies "f->do_oop" to all root oops in the system dictionary. |
|
335 |
static void oops_do(OopClosure* f); |
|
336 |
||
337 |
// System loader lock |
|
338 |
static oop system_loader_lock() { return _system_loader_lock_obj; } |
|
339 |
||
340 |
private: |
|
341 |
// Traverses preloaded oops: various system classes. These are |
|
342 |
// guaranteed to be in the perm gen. |
|
343 |
static void preloaded_oops_do(OopClosure* f); |
|
344 |
static void lazily_loaded_oops_do(OopClosure* f); |
|
345 |
||
346 |
public: |
|
347 |
// Sharing support. |
|
348 |
static void reorder_dictionary(); |
|
349 |
static void copy_buckets(char** top, char* end); |
|
350 |
static void copy_table(char** top, char* end); |
|
351 |
static void reverse(); |
|
352 |
static void set_shared_dictionary(HashtableBucket* t, int length, |
|
353 |
int number_of_entries); |
|
354 |
// Printing |
|
355 |
static void print() PRODUCT_RETURN; |
|
356 |
static void print_class_statistics() PRODUCT_RETURN; |
|
357 |
static void print_method_statistics() PRODUCT_RETURN; |
|
358 |
||
359 |
// Number of contained klasses |
|
360 |
// This is both fully loaded classes and classes in the process |
|
361 |
// of being loaded |
|
362 |
static int number_of_classes(); |
|
363 |
||
364 |
// Monotonically increasing counter which grows as classes are |
|
365 |
// loaded or modifications such as hot-swapping or setting/removing |
|
366 |
// of breakpoints are performed |
|
367 |
static inline int number_of_modifications() { assert_locked_or_safepoint(Compile_lock); return _number_of_modifications; } |
|
368 |
// Needed by evolution and breakpoint code |
|
369 |
static inline void notice_modification() { assert_locked_or_safepoint(Compile_lock); ++_number_of_modifications; } |
|
370 |
||
371 |
// Verification |
|
372 |
static void verify(); |
|
373 |
||
374 |
#ifdef ASSERT |
|
375 |
static bool is_internal_format(symbolHandle class_name); |
|
376 |
#endif |
|
377 |
||
378 |
// Verify class is in dictionary |
|
379 |
static void verify_obj_klass_present(Handle obj, |
|
380 |
symbolHandle class_name, |
|
381 |
Handle class_loader); |
|
382 |
||
383 |
// Initialization |
|
384 |
static void initialize(TRAPS); |
|
385 |
||
386 |
// Fast access to commonly used classes (preloaded) |
|
387 |
static klassOop check_klass(klassOop k) { |
|
388 |
assert(k != NULL, "preloaded klass not initialized"); |
|
389 |
return k; |
|
390 |
} |
|
391 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
392 |
static klassOop check_klass_Pre(klassOop k) { return check_klass(k); } |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
393 |
static klassOop check_klass_Opt(klassOop k) { return k; } |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
394 |
static klassOop check_klass_Opt_Kernel(klassOop k) { return k; } //== Opt |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
395 |
static klassOop check_klass_Opt_Only_JDK15(klassOop k) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
396 |
assert(JDK_Version::is_gte_jdk15x_version(), "JDK 1.5 only"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
397 |
return k; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
398 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
399 |
static klassOop check_klass_Opt_Only_JDK14NewRef(klassOop k) { |
1 | 400 |
assert(JDK_Version::is_gte_jdk14x_version() && UseNewReflection, "JDK 1.4 only"); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
401 |
// despite the optional loading, if you use this it must be present: |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
402 |
return check_klass(k); |
1 | 403 |
} |
404 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
405 |
static bool initialize_wk_klass(WKID id, int init_opt, TRAPS); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
406 |
static void initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
407 |
static void initialize_wk_klasses_through(WKID end_id, WKID &start_id, TRAPS) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
408 |
int limit = (int)end_id + 1; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
409 |
initialize_wk_klasses_until((WKID) limit, start_id, THREAD); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
410 |
} |
1 | 411 |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
412 |
public: |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
413 |
#define WK_KLASS_DECLARE(name, ignore_symbol, option) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
414 |
static klassOop name() { return check_klass_##option(_well_known_klasses[WK_KLASS_ENUM_NAME(name)]); } |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
415 |
WK_KLASSES_DO(WK_KLASS_DECLARE); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
416 |
#undef WK_KLASS_DECLARE |
1 | 417 |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
418 |
// Local definition for direct access to the private array: |
394 | 419 |
#define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)] |
1 | 420 |
|
421 |
static klassOop box_klass(BasicType t) { |
|
422 |
assert((uint)t < T_VOID+1, "range check"); |
|
423 |
return check_klass(_box_klasses[t]); |
|
424 |
} |
|
425 |
static BasicType box_klass_type(klassOop k); // inverse of box_klass |
|
426 |
||
427 |
// methods returning lazily loaded klasses |
|
428 |
// The corresponding method to load the class must be called before calling them. |
|
429 |
static klassOop abstract_ownable_synchronizer_klass() { return check_klass(_abstract_ownable_synchronizer_klass); } |
|
430 |
||
431 |
static void load_abstract_ownable_synchronizer_klass(TRAPS); |
|
432 |
||
433 |
private: |
|
434 |
// Tells whether ClassLoader.loadClassInternal is present |
|
435 |
static bool has_loadClassInternal() { return _has_loadClassInternal; } |
|
436 |
||
437 |
public: |
|
438 |
// Tells whether ClassLoader.checkPackageAccess is present |
|
439 |
static bool has_checkPackageAccess() { return _has_checkPackageAccess; } |
|
440 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
441 |
static bool class_klass_loaded() { return WK_KLASS(class_klass) != NULL; } |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
442 |
static bool cloneable_klass_loaded() { return WK_KLASS(cloneable_klass) != NULL; } |
1 | 443 |
|
444 |
// Returns default system loader |
|
445 |
static oop java_system_loader(); |
|
446 |
||
447 |
// Compute the default system loader |
|
448 |
static void compute_java_system_loader(TRAPS); |
|
449 |
||
450 |
private: |
|
451 |
// Mirrors for primitive classes (created eagerly) |
|
452 |
static oop check_mirror(oop m) { |
|
453 |
assert(m != NULL, "mirror not initialized"); |
|
454 |
return m; |
|
455 |
} |
|
456 |
||
457 |
public: |
|
458 |
// Note: java_lang_Class::primitive_type is the inverse of java_mirror |
|
459 |
||
460 |
// Check class loader constraints |
|
461 |
static bool add_loader_constraint(symbolHandle name, Handle loader1, |
|
462 |
Handle loader2, TRAPS); |
|
463 |
static char* check_signature_loaders(symbolHandle signature, Handle loader1, |
|
464 |
Handle loader2, bool is_method, TRAPS); |
|
465 |
||
2534 | 466 |
// JSR 292 |
467 |
// find the java.dyn.MethodHandles::invoke method for a given signature |
|
468 |
static methodOop find_method_handle_invoke(symbolHandle signature, |
|
469 |
Handle class_loader, |
|
470 |
Handle protection_domain, |
|
471 |
TRAPS); |
|
472 |
// ask Java to compute the java.dyn.MethodType object for a given signature |
|
473 |
static Handle compute_method_handle_type(symbolHandle signature, |
|
474 |
Handle class_loader, |
|
475 |
Handle protection_domain, |
|
476 |
TRAPS); |
|
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
477 |
// ask Java to create a dynamic call site, while linking an invokedynamic op |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
478 |
static Handle make_dynamic_call_site(KlassHandle caller, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
479 |
int caller_method_idnum, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
480 |
int caller_bci, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
481 |
symbolHandle name, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
482 |
methodHandle mh_invoke, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
483 |
TRAPS); |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
484 |
|
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
485 |
// coordinate with Java about bootstrap methods |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
486 |
static Handle find_bootstrap_method(KlassHandle caller, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
487 |
// This argument is non-null only when a |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
488 |
// classfile attribute has been found: |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
489 |
KlassHandle search_bootstrap_klass, |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
490 |
TRAPS); |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
491 |
|
1 | 492 |
// Utility for printing loader "name" as part of tracing constraints |
493 |
static const char* loader_name(oop loader) { |
|
494 |
return ((loader) == NULL ? "<bootloader>" : |
|
495 |
instanceKlass::cast((loader)->klass())->name()->as_C_string() ); |
|
496 |
} |
|
497 |
||
498 |
// Record the error when the first attempt to resolve a reference from a constant |
|
499 |
// pool entry to a class fails. |
|
500 |
static void add_resolution_error(constantPoolHandle pool, int which, symbolHandle error); |
|
501 |
static symbolOop find_resolution_error(constantPoolHandle pool, int which); |
|
502 |
||
503 |
private: |
|
504 |
||
505 |
enum Constants { |
|
506 |
_loader_constraint_size = 107, // number of entries in constraint table |
|
507 |
_resolution_error_size = 107, // number of entries in resolution error table |
|
2534 | 508 |
_invoke_method_size = 139, // number of entries in invoke method table |
1 | 509 |
_nof_buckets = 1009 // number of buckets in hash table |
510 |
}; |
|
511 |
||
512 |
||
513 |
// Static variables |
|
514 |
||
515 |
// Hashtable holding loaded classes. |
|
516 |
static Dictionary* _dictionary; |
|
517 |
||
518 |
// Hashtable holding placeholders for classes being loaded. |
|
519 |
static PlaceholderTable* _placeholders; |
|
520 |
||
521 |
// Hashtable holding classes from the shared archive. |
|
522 |
static Dictionary* _shared_dictionary; |
|
523 |
||
524 |
// Monotonically increasing counter which grows with |
|
525 |
// _number_of_classes as well as hot-swapping and breakpoint setting |
|
526 |
// and removal. |
|
527 |
static int _number_of_modifications; |
|
528 |
||
529 |
// Lock object for system class loader |
|
530 |
static oop _system_loader_lock_obj; |
|
531 |
||
532 |
// Constraints on class loaders |
|
533 |
static LoaderConstraintTable* _loader_constraints; |
|
534 |
||
535 |
// Resolution errors |
|
536 |
static ResolutionErrorTable* _resolution_errors; |
|
537 |
||
2534 | 538 |
// Invoke methods (JSR 292) |
539 |
static SymbolPropertyTable* _invoke_method_table; |
|
540 |
||
1 | 541 |
public: |
542 |
// for VM_CounterDecay iteration support |
|
543 |
friend class CounterDecay; |
|
544 |
static klassOop try_get_next_class(); |
|
545 |
||
546 |
private: |
|
547 |
static void validate_protection_domain(instanceKlassHandle klass, |
|
548 |
Handle class_loader, |
|
549 |
Handle protection_domain, TRAPS); |
|
550 |
||
551 |
friend class VM_PopulateDumpSharedSpace; |
|
552 |
friend class TraversePlaceholdersClosure; |
|
553 |
static Dictionary* dictionary() { return _dictionary; } |
|
554 |
static Dictionary* shared_dictionary() { return _shared_dictionary; } |
|
555 |
static PlaceholderTable* placeholders() { return _placeholders; } |
|
556 |
static LoaderConstraintTable* constraints() { return _loader_constraints; } |
|
557 |
static ResolutionErrorTable* resolution_errors() { return _resolution_errors; } |
|
2534 | 558 |
static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; } |
1 | 559 |
|
560 |
// Basic loading operations |
|
561 |
static klassOop resolve_instance_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
562 |
static klassOop resolve_array_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
563 |
static instanceKlassHandle handle_parallel_super_load(symbolHandle class_name, symbolHandle supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS); |
|
564 |
// Wait on SystemDictionary_lock; unlocks lockObject before |
|
565 |
// waiting; relocks lockObject with correct recursion count |
|
566 |
// after waiting, but before reentering SystemDictionary_lock |
|
567 |
// to preserve lock order semantics. |
|
568 |
static void double_lock_wait(Handle lockObject, TRAPS); |
|
569 |
static void define_instance_class(instanceKlassHandle k, TRAPS); |
|
570 |
static instanceKlassHandle find_or_define_instance_class(symbolHandle class_name, |
|
571 |
Handle class_loader, |
|
572 |
instanceKlassHandle k, TRAPS); |
|
573 |
static instanceKlassHandle load_shared_class(symbolHandle class_name, |
|
574 |
Handle class_loader, TRAPS); |
|
575 |
static instanceKlassHandle load_shared_class(instanceKlassHandle ik, |
|
576 |
Handle class_loader, TRAPS); |
|
577 |
static instanceKlassHandle load_instance_class(symbolHandle class_name, Handle class_loader, TRAPS); |
|
578 |
static Handle compute_loader_lock_object(Handle class_loader, TRAPS); |
|
579 |
static void check_loader_lock_contention(Handle loader_lock, TRAPS); |
|
1890 | 580 |
static bool is_parallelCapable(Handle class_loader); |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
3820
diff
changeset
|
581 |
static bool is_parallelDefine(Handle class_loader); |
1 | 582 |
|
583 |
static klassOop find_shared_class(symbolHandle class_name); |
|
584 |
||
585 |
// Setup link to hierarchy |
|
586 |
static void add_to_hierarchy(instanceKlassHandle k, TRAPS); |
|
587 |
||
588 |
private: |
|
589 |
// We pass in the hashtable index so we can calculate it outside of |
|
590 |
// the SystemDictionary_lock. |
|
591 |
||
592 |
// Basic find on loaded classes |
|
593 |
static klassOop find_class(int index, unsigned int hash, |
|
594 |
symbolHandle name, Handle loader); |
|
595 |
||
596 |
// Basic find on classes in the midst of being loaded |
|
597 |
static symbolOop find_placeholder(int index, unsigned int hash, |
|
598 |
symbolHandle name, Handle loader); |
|
599 |
||
600 |
// Basic find operation of loaded classes and classes in the midst |
|
601 |
// of loading; used for assertions and verification only. |
|
602 |
static oop find_class_or_placeholder(symbolHandle class_name, |
|
603 |
Handle class_loader); |
|
604 |
||
605 |
// Updating entry in dictionary |
|
606 |
// Add a completely loaded class |
|
607 |
static void add_klass(int index, symbolHandle class_name, |
|
608 |
Handle class_loader, KlassHandle obj); |
|
609 |
||
610 |
// Add a placeholder for a class being loaded |
|
611 |
static void add_placeholder(int index, |
|
612 |
symbolHandle class_name, |
|
613 |
Handle class_loader); |
|
614 |
static void remove_placeholder(int index, |
|
615 |
symbolHandle class_name, |
|
616 |
Handle class_loader); |
|
617 |
||
618 |
// Performs cleanups after resolve_super_or_fail. This typically needs |
|
619 |
// to be called on failure. |
|
620 |
// Won't throw, but can block. |
|
621 |
static void resolution_cleanups(symbolHandle class_name, |
|
622 |
Handle class_loader, |
|
623 |
TRAPS); |
|
624 |
||
625 |
// Initialization |
|
626 |
static void initialize_preloaded_classes(TRAPS); |
|
627 |
||
628 |
// Class loader constraints |
|
629 |
static void check_constraints(int index, unsigned int hash, |
|
630 |
instanceKlassHandle k, Handle loader, |
|
631 |
bool defining, TRAPS); |
|
632 |
static void update_dictionary(int d_index, unsigned int d_hash, |
|
633 |
int p_index, unsigned int p_hash, |
|
634 |
instanceKlassHandle k, Handle loader, TRAPS); |
|
635 |
||
636 |
// Variables holding commonly used klasses (preloaded) |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
637 |
static klassOop _well_known_klasses[]; |
1 | 638 |
|
639 |
// Lazily loaded klasses |
|
640 |
static volatile klassOop _abstract_ownable_synchronizer_klass; |
|
641 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
1
diff
changeset
|
642 |
// table of box klasses (int_klass, etc.) |
1 | 643 |
static klassOop _box_klasses[T_VOID+1]; |
644 |
||
645 |
static oop _java_system_loader; |
|
646 |
||
647 |
static bool _has_loadClassInternal; |
|
648 |
static bool _has_checkPackageAccess; |
|
649 |
}; |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
650 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
651 |
// Cf. vmSymbols vs. vmSymbolHandles |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
652 |
class SystemDictionaryHandles : AllStatic { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
653 |
public: |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
654 |
#define WK_KLASS_HANDLE_DECLARE(name, ignore_symbol, option) \ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
655 |
static KlassHandle name() { \ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
656 |
SystemDictionary::name(); \ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
657 |
klassOop* loc = &SystemDictionary::_well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]; \ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
658 |
return KlassHandle(loc, true); \ |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
659 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
660 |
WK_KLASSES_DO(WK_KLASS_HANDLE_DECLARE); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
661 |
#undef WK_KLASS_HANDLE_DECLARE |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
662 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
663 |
static KlassHandle box_klass(BasicType t); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
664 |
}; |