Mercurial > hg > truffle
annotate src/share/vm/classfile/systemDictionary.hpp @ 3762:5c0a3c1858b1
7048782: CMS: assert(last_chunk_index_to_check<= last_chunk_index) failed: parCardTableModRefBS.cpp:359
Summary: The LNC array is sized before the start of a scavenge, while the heap may expand during a scavenge. With CMS, the last block of an arbitrary suffice of the LNC array may expand due to coalition with the expansion delta. We now take care not to attempt access past the end of the LNC array. LNC array code will be cleaned up and suitably encapsulated as part of the forthcoming performance RFE 7043675.
Reviewed-by: brutisso
| author | ysr |
|---|---|
| date | Thu, 02 Jun 2011 10:23:36 -0700 |
| parents | ed69575596ac |
| children | 0654ee04b214 ba550512d3b2 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2001
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP |
| 26 #define SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP | |
| 27 | |
| 28 #include "classfile/classFileStream.hpp" | |
| 29 #include "classfile/classLoader.hpp" | |
| 30 #include "oops/objArrayOop.hpp" | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
31 #include "oops/symbol.hpp" |
| 1972 | 32 #include "runtime/java.hpp" |
| 33 #include "runtime/reflectionUtils.hpp" | |
| 34 #include "utilities/hashtable.hpp" | |
| 35 | |
| 0 | 36 // The system dictionary stores all loaded classes and maps: |
| 37 // | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
38 // [class name,class loader] -> class i.e. [Symbol*,oop] -> klassOop |
| 0 | 39 // |
| 40 // Classes are loaded lazily. The default VM class loader is | |
| 41 // represented as NULL. | |
| 42 | |
| 43 // The underlying data structure is an open hash table with a fixed number | |
| 44 // of buckets. During loading the loader object is locked, (for the VM loader | |
| 45 // a private lock object is used). Class loading can thus be done concurrently, | |
| 46 // but only by different loaders. | |
| 47 // | |
| 48 // During loading a placeholder (name, loader) is temporarily placed in | |
| 49 // a side data structure, and is used to detect ClassCircularityErrors | |
| 50 // and to perform verification during GC. A GC can occur in the midst | |
| 51 // of class loading, as we call out to Java, have to take locks, etc. | |
| 52 // | |
| 53 // When class loading is finished, a new entry is added to the system | |
| 54 // dictionary and the place holder is removed. Note that the protection | |
| 55 // domain field of the system dictionary has not yet been filled in when | |
| 56 // the "real" system dictionary entry is created. | |
| 57 // | |
| 58 // Clients of this class who are interested in finding if a class has | |
| 59 // been completely loaded -- not classes in the process of being loaded -- | |
| 60 // can read the SystemDictionary unlocked. This is safe because | |
| 61 // - entries are only deleted at safepoints | |
| 62 // - readers cannot come to a safepoint while actively examining | |
| 63 // an entry (an entry cannot be deleted from under a reader) | |
| 64 // - entries must be fully formed before they are available to concurrent | |
| 65 // readers (we must ensure write ordering) | |
| 66 // | |
| 67 // Note that placeholders are deleted at any time, as they are removed | |
| 68 // when a class is completely loaded. Therefore, readers as well as writers | |
| 69 // of placeholders must hold the SystemDictionary_lock. | |
| 70 // | |
| 71 | |
| 72 class Dictionary; | |
| 73 class PlaceholderTable; | |
| 74 class LoaderConstraintTable; | |
| 75 class HashtableBucket; | |
| 76 class ResolutionErrorTable; | |
| 710 | 77 class SymbolPropertyTable; |
| 0 | 78 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
79 // Certain classes are preloaded, such as java.lang.Object and java.lang.String. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
80 // They are all "well-known", in the sense that no class loader is allowed |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
81 // to provide a different definition. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
82 // |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
83 // These klasses must all have names defined in vmSymbols. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
84 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
85 #define WK_KLASS_ENUM_NAME(kname) kname##_knum |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
86 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
87 // Each well-known class has a short klass name (like object_klass), |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
88 // a vmSymbol name (like java_lang_Object), and a flag word |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
89 // that makes some minor distinctions, like whether the klass |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
90 // is preloaded, optional, release-specific, etc. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
91 // The order of these definitions is significant; it is the order in which |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
92 // preloading is actually performed by initialize_preloaded_classes. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
93 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
94 #define WK_KLASSES_DO(template) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
95 /* well-known classes */ \ |
| 1142 | 96 template(Object_klass, java_lang_Object, Pre) \ |
| 97 template(String_klass, java_lang_String, Pre) \ | |
| 98 template(Class_klass, java_lang_Class, Pre) \ | |
| 99 template(Cloneable_klass, java_lang_Cloneable, Pre) \ | |
| 100 template(ClassLoader_klass, java_lang_ClassLoader, Pre) \ | |
| 101 template(Serializable_klass, java_io_Serializable, Pre) \ | |
| 102 template(System_klass, java_lang_System, Pre) \ | |
| 103 template(Throwable_klass, java_lang_Throwable, Pre) \ | |
| 104 template(Error_klass, java_lang_Error, Pre) \ | |
| 105 template(ThreadDeath_klass, java_lang_ThreadDeath, Pre) \ | |
| 106 template(Exception_klass, java_lang_Exception, Pre) \ | |
| 107 template(RuntimeException_klass, java_lang_RuntimeException, Pre) \ | |
| 108 template(ProtectionDomain_klass, java_security_ProtectionDomain, Pre) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
109 template(AccessControlContext_klass, java_security_AccessControlContext, Pre) \ |
| 1142 | 110 template(ClassNotFoundException_klass, java_lang_ClassNotFoundException, Pre) \ |
| 111 template(NoClassDefFoundError_klass, java_lang_NoClassDefFoundError, Pre) \ | |
| 112 template(LinkageError_klass, java_lang_LinkageError, Pre) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
113 template(ClassCastException_klass, java_lang_ClassCastException, Pre) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
114 template(ArrayStoreException_klass, java_lang_ArrayStoreException, Pre) \ |
| 1142 | 115 template(VirtualMachineError_klass, java_lang_VirtualMachineError, Pre) \ |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
116 template(OutOfMemoryError_klass, java_lang_OutOfMemoryError, Pre) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
117 template(StackOverflowError_klass, java_lang_StackOverflowError, Pre) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
118 template(IllegalMonitorStateException_klass, java_lang_IllegalMonitorStateException, Pre) \ |
| 1142 | 119 template(Reference_klass, java_lang_ref_Reference, Pre) \ |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
120 \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
121 /* Preload ref klasses and set reference types */ \ |
| 1142 | 122 template(SoftReference_klass, java_lang_ref_SoftReference, Pre) \ |
| 123 template(WeakReference_klass, java_lang_ref_WeakReference, Pre) \ | |
| 124 template(FinalReference_klass, java_lang_ref_FinalReference, Pre) \ | |
| 125 template(PhantomReference_klass, java_lang_ref_PhantomReference, Pre) \ | |
| 126 template(Finalizer_klass, java_lang_ref_Finalizer, Pre) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
127 \ |
| 1142 | 128 template(Thread_klass, java_lang_Thread, Pre) \ |
| 129 template(ThreadGroup_klass, java_lang_ThreadGroup, Pre) \ | |
| 130 template(Properties_klass, java_util_Properties, Pre) \ | |
| 131 template(reflect_AccessibleObject_klass, java_lang_reflect_AccessibleObject, Pre) \ | |
| 132 template(reflect_Field_klass, java_lang_reflect_Field, Pre) \ | |
| 133 template(reflect_Method_klass, java_lang_reflect_Method, Pre) \ | |
| 134 template(reflect_Constructor_klass, java_lang_reflect_Constructor, Pre) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
135 \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
136 /* NOTE: needed too early in bootstrapping process to have checks based on JDK version */ \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
137 /* Universe::is_gte_jdk14x_version() is not set up by this point. */ \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
138 /* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \ |
| 1142 | 139 template(reflect_MagicAccessorImpl_klass, sun_reflect_MagicAccessorImpl, Opt) \ |
| 140 template(reflect_MethodAccessorImpl_klass, sun_reflect_MethodAccessorImpl, Opt_Only_JDK14NewRef) \ | |
| 141 template(reflect_ConstructorAccessorImpl_klass, sun_reflect_ConstructorAccessorImpl, Opt_Only_JDK14NewRef) \ | |
| 142 template(reflect_DelegatingClassLoader_klass, sun_reflect_DelegatingClassLoader, Opt) \ | |
| 143 template(reflect_ConstantPool_klass, sun_reflect_ConstantPool, Opt_Only_JDK15) \ | |
| 144 template(reflect_UnsafeStaticFieldAccessorImpl_klass, sun_reflect_UnsafeStaticFieldAccessorImpl, Opt_Only_JDK15) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
145 \ |
| 710 | 146 /* support for dynamic typing; it's OK if these are NULL in earlier JDKs */ \ |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
147 template(MethodHandle_klass, java_lang_invoke_MethodHandle, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
148 template(MemberName_klass, java_lang_invoke_MemberName, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
149 template(MethodHandleNatives_klass, java_lang_invoke_MethodHandleNatives, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
150 template(AdapterMethodHandle_klass, java_lang_invoke_AdapterMethodHandle, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
151 template(BoundMethodHandle_klass, java_lang_invoke_BoundMethodHandle, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
152 template(DirectMethodHandle_klass, java_lang_invoke_DirectMethodHandle, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
153 template(MethodType_klass, java_lang_invoke_MethodType, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
154 template(MethodTypeForm_klass, java_lang_invoke_MethodTypeForm, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
155 template(WrongMethodTypeException_klass, java_lang_invoke_WrongMethodTypeException, Pre_JSR292) \ |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
156 template(CallSite_klass, java_lang_invoke_CallSite, Pre_JSR292) \ |
|
2001
f2da85a9b08e
7001363: java/dyn/InvokeDynamic should not be a well-known class in the JVM
twisti
parents:
1972
diff
changeset
|
157 /* Note: MethodHandle must be first, and CallSite last in group */ \ |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
158 \ |
| 1142 | 159 template(StringBuffer_klass, java_lang_StringBuffer, Pre) \ |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1059
diff
changeset
|
160 template(StringBuilder_klass, java_lang_StringBuilder, Pre) \ |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
161 \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
162 /* It's NULL in non-1.4 JDKs. */ \ |
| 1142 | 163 template(StackTraceElement_klass, java_lang_StackTraceElement, Opt) \ |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
164 /* Universe::is_gte_jdk14x_version() is not set up by this point. */ \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
165 /* It's okay if this turns out to be NULL in non-1.4 JDKs. */ \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
166 template(java_nio_Buffer_klass, java_nio_Buffer, Opt) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
167 \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
168 /* If this class isn't present, it won't be referenced. */ \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
169 template(sun_misc_AtomicLongCSImpl_klass, sun_misc_AtomicLongCSImpl, Opt) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
170 \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
171 template(sun_jkernel_DownloadManager_klass, sun_jkernel_DownloadManager, Opt_Kernel) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
172 \ |
|
2129
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2001
diff
changeset
|
173 template(sun_misc_PostVMInitHook_klass, sun_misc_PostVMInitHook, Opt) \ |
|
8f8dfba37802
6994753: Implement optional hook to a Java method at VM startup.
kevinw
parents:
2001
diff
changeset
|
174 \ |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
175 /* Preload boxing klasses */ \ |
| 1142 | 176 template(Boolean_klass, java_lang_Boolean, Pre) \ |
| 177 template(Character_klass, java_lang_Character, Pre) \ | |
| 178 template(Float_klass, java_lang_Float, Pre) \ | |
| 179 template(Double_klass, java_lang_Double, Pre) \ | |
| 180 template(Byte_klass, java_lang_Byte, Pre) \ | |
| 181 template(Short_klass, java_lang_Short, Pre) \ | |
| 182 template(Integer_klass, java_lang_Integer, Pre) \ | |
| 183 template(Long_klass, java_lang_Long, Pre) \ | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
184 /*end*/ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
185 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
186 |
| 0 | 187 class SystemDictionary : AllStatic { |
| 188 friend class VMStructs; | |
| 189 friend class CompactingPermGenGen; | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
190 friend class SystemDictionaryHandles; |
| 0 | 191 NOT_PRODUCT(friend class instanceKlassKlass;) |
| 192 | |
| 193 public: | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
194 enum WKID { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
195 NO_WKID = 0, |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
196 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
197 #define WK_KLASS_ENUM(name, ignore_s, ignore_o) WK_KLASS_ENUM_NAME(name), |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
198 WK_KLASSES_DO(WK_KLASS_ENUM) |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
199 #undef WK_KLASS_ENUM |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
200 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
201 WKID_LIMIT, |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
202 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
203 FIRST_WKID = NO_WKID + 1 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
204 }; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
205 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
206 enum InitOption { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
207 Pre, // preloaded; error if not present |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
208 Pre_JSR292, // preloaded if EnableInvokeDynamic |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
209 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
210 // Order is significant. Options before this point require resolve_or_fail. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
211 // Options after this point will use resolve_or_null instead. |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
212 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
213 Opt, // preload tried; NULL if not present |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
214 Opt_Only_JDK14NewRef, // preload tried; use only with NewReflection |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
215 Opt_Only_JDK15, // preload tried; use only with JDK1.5+ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
216 Opt_Kernel, // preload tried only #ifdef KERNEL |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
217 OPTION_LIMIT, |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
218 CEIL_LG_OPTION_LIMIT = 4 // OPTION_LIMIT <= (1<<CEIL_LG_OPTION_LIMIT) |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
219 }; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
220 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
221 |
| 0 | 222 // Returns a class with a given class name and class loader. Loads the |
| 223 // class if needed. If not found a NoClassDefFoundError or a | |
| 224 // ClassNotFoundException is thrown, depending on the value on the | |
| 225 // throw_error flag. For most uses the throw_error argument should be set | |
| 226 // to true. | |
| 227 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
228 static klassOop resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS); |
| 0 | 229 // Convenient call for null loader and protection domain. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
230 static klassOop resolve_or_fail(Symbol* class_name, bool throw_error, TRAPS); |
| 0 | 231 private: |
| 232 // handle error translation for resolve_or_null results | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
233 static klassOop handle_resolution_exception(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS); |
| 0 | 234 |
| 235 public: | |
| 236 | |
| 237 // Returns a class with a given class name and class loader. | |
| 238 // Loads the class if needed. If not found NULL is returned. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
239 static klassOop resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); |
| 0 | 240 // Version with null loader and protection domain |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
241 static klassOop resolve_or_null(Symbol* class_name, TRAPS); |
| 0 | 242 |
| 243 // Resolve a superclass or superinterface. Called from ClassFileParser, | |
| 244 // parse_interfaces, resolve_instance_class_or_null, load_shared_class | |
| 245 // "child_name" is the class whose super class or interface is being resolved. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
246 static klassOop resolve_super_or_fail(Symbol* child_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
247 Symbol* class_name, |
| 0 | 248 Handle class_loader, |
| 249 Handle protection_domain, | |
| 250 bool is_superclass, | |
| 251 TRAPS); | |
| 252 | |
| 253 // Parse new stream. This won't update the system dictionary or | |
| 254 // class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
255 static klassOop parse_stream(Symbol* class_name, |
| 0 | 256 Handle class_loader, |
| 257 Handle protection_domain, | |
| 258 ClassFileStream* st, | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
259 TRAPS) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
260 KlassHandle nullHandle; |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
261 return parse_stream(class_name, class_loader, protection_domain, st, nullHandle, NULL, THREAD); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
262 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
263 static klassOop parse_stream(Symbol* class_name, |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
264 Handle class_loader, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
265 Handle protection_domain, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
266 ClassFileStream* st, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
267 KlassHandle host_klass, |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
268 GrowableArray<Handle>* cp_patches, |
| 0 | 269 TRAPS); |
| 270 | |
| 271 // Resolve from stream (called by jni_DefineClass and JVM_DefineClass) | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
272 static klassOop resolve_from_stream(Symbol* class_name, Handle class_loader, |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
273 Handle protection_domain, |
|
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
726
diff
changeset
|
274 ClassFileStream* st, bool verify, TRAPS); |
| 0 | 275 |
| 276 // Lookup an already loaded class. If not found NULL is returned. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
277 static klassOop find(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); |
| 0 | 278 |
| 279 // Lookup an already loaded instance or array class. | |
| 280 // Do not make any queries to class loaders; consult only the cache. | |
| 281 // If not found NULL is returned. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
282 static klassOop find_instance_or_array_klass(Symbol* class_name, |
| 0 | 283 Handle class_loader, |
| 284 Handle protection_domain, | |
| 285 TRAPS); | |
| 286 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
287 // If the given name is known to vmSymbols, return the well-know klass: |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
288 static klassOop find_well_known_klass(Symbol* class_name); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
289 |
| 0 | 290 // Lookup an instance or array class that has already been loaded |
| 291 // either into the given class loader, or else into another class | |
| 292 // loader that is constrained (via loader constraints) to produce | |
| 293 // a consistent class. Do not take protection domains into account. | |
| 294 // Do not make any queries to class loaders; consult only the cache. | |
| 295 // Return NULL if the class is not found. | |
| 296 // | |
| 297 // This function is a strict superset of find_instance_or_array_klass. | |
| 298 // This function (the unchecked version) makes a conservative prediction | |
| 299 // of the result of the checked version, assuming successful lookup. | |
| 300 // If both functions return non-null, they must return the same value. | |
| 301 // Also, the unchecked version may sometimes be non-null where the | |
| 302 // checked version is null. This can occur in several ways: | |
| 303 // 1. No query has yet been made to the class loader. | |
| 304 // 2. The class loader was queried, but chose not to delegate. | |
| 305 // 3. ClassLoader.checkPackageAccess rejected a proposed protection domain. | |
| 306 // 4. Loading was attempted, but there was a linkage error of some sort. | |
| 307 // In all of these cases, the loader constraints on this type are | |
| 308 // satisfied, and it is safe for classes in the given class loader | |
| 309 // to manipulate strongly-typed values of the found class, subject | |
| 310 // to local linkage and access checks. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
311 static klassOop find_constrained_instance_or_array_klass(Symbol* class_name, |
| 0 | 312 Handle class_loader, |
| 313 TRAPS); | |
| 314 | |
| 315 // Iterate over all klasses in dictionary | |
| 316 // Just the classes from defining class loaders | |
| 317 static void classes_do(void f(klassOop)); | |
| 318 // Added for initialize_itable_for_klass to handle exceptions | |
| 319 static void classes_do(void f(klassOop, TRAPS), TRAPS); | |
| 320 // All classes, and their class loaders | |
| 321 static void classes_do(void f(klassOop, oop)); | |
| 322 // All classes, and their class loaders | |
| 323 // (added for helpers that use HandleMarks and ResourceMarks) | |
| 324 static void classes_do(void f(klassOop, oop, TRAPS), TRAPS); | |
| 325 // All entries in the placeholder table and their class loaders | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
326 static void placeholders_do(void f(Symbol*, oop)); |
| 0 | 327 |
| 328 // Iterate over all methods in all klasses in dictionary | |
| 329 static void methods_do(void f(methodOop)); | |
| 330 | |
| 331 // Garbage collection support | |
| 332 | |
| 333 // This method applies "blk->do_oop" to all the pointers to "system" | |
| 334 // classes and loaders. | |
| 335 static void always_strong_oops_do(OopClosure* blk); | |
| 336 static void always_strong_classes_do(OopClosure* blk); | |
| 337 // This method applies "blk->do_oop" to all the placeholders. | |
| 338 static void placeholders_do(OopClosure* blk); | |
| 339 | |
| 340 // Unload (that is, break root links to) all unmarked classes and | |
| 341 // loaders. Returns "true" iff something was unloaded. | |
| 342 static bool do_unloading(BoolObjectClosure* is_alive); | |
| 343 | |
| 344 // Applies "f->do_oop" to all root oops in the system dictionary. | |
| 345 static void oops_do(OopClosure* f); | |
| 346 | |
| 347 // System loader lock | |
| 348 static oop system_loader_lock() { return _system_loader_lock_obj; } | |
| 349 | |
| 350 private: | |
| 351 // Traverses preloaded oops: various system classes. These are | |
| 352 // guaranteed to be in the perm gen. | |
| 353 static void preloaded_oops_do(OopClosure* f); | |
| 354 static void lazily_loaded_oops_do(OopClosure* f); | |
| 355 | |
| 356 public: | |
| 357 // Sharing support. | |
| 358 static void reorder_dictionary(); | |
| 359 static void copy_buckets(char** top, char* end); | |
| 360 static void copy_table(char** top, char* end); | |
| 361 static void reverse(); | |
| 362 static void set_shared_dictionary(HashtableBucket* t, int length, | |
| 363 int number_of_entries); | |
| 364 // Printing | |
| 365 static void print() PRODUCT_RETURN; | |
| 366 static void print_class_statistics() PRODUCT_RETURN; | |
| 367 static void print_method_statistics() PRODUCT_RETURN; | |
| 368 | |
| 369 // Number of contained klasses | |
| 370 // This is both fully loaded classes and classes in the process | |
| 371 // of being loaded | |
| 372 static int number_of_classes(); | |
| 373 | |
| 374 // Monotonically increasing counter which grows as classes are | |
| 375 // loaded or modifications such as hot-swapping or setting/removing | |
| 376 // of breakpoints are performed | |
| 377 static inline int number_of_modifications() { assert_locked_or_safepoint(Compile_lock); return _number_of_modifications; } | |
| 378 // Needed by evolution and breakpoint code | |
| 379 static inline void notice_modification() { assert_locked_or_safepoint(Compile_lock); ++_number_of_modifications; } | |
| 380 | |
| 381 // Verification | |
| 382 static void verify(); | |
| 383 | |
| 384 #ifdef ASSERT | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
385 static bool is_internal_format(Symbol* class_name); |
| 0 | 386 #endif |
| 387 | |
| 388 // Verify class is in dictionary | |
| 389 static void verify_obj_klass_present(Handle obj, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
390 Symbol* class_name, |
| 0 | 391 Handle class_loader); |
| 392 | |
| 393 // Initialization | |
| 394 static void initialize(TRAPS); | |
| 395 | |
| 396 // Fast access to commonly used classes (preloaded) | |
| 397 static klassOop check_klass(klassOop k) { | |
| 398 assert(k != NULL, "preloaded klass not initialized"); | |
| 399 return k; | |
| 400 } | |
| 401 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
402 static klassOop check_klass_Pre(klassOop k) { return check_klass(k); } |
|
2356
72dee110246f
6839872: remove implementation inheritance from JSR 292 APIs
jrose
parents:
2177
diff
changeset
|
403 static klassOop check_klass_Pre_JSR292(klassOop k) { return EnableInvokeDynamic ? check_klass(k) : k; } |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
404 static klassOop check_klass_Opt(klassOop k) { return k; } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
405 static klassOop check_klass_Opt_Kernel(klassOop k) { return k; } //== Opt |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
406 static klassOop check_klass_Opt_Only_JDK15(klassOop k) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
407 assert(JDK_Version::is_gte_jdk15x_version(), "JDK 1.5 only"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
408 return k; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
409 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
410 static klassOop check_klass_Opt_Only_JDK14NewRef(klassOop k) { |
| 0 | 411 assert(JDK_Version::is_gte_jdk14x_version() && UseNewReflection, "JDK 1.4 only"); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
412 // despite the optional loading, if you use this it must be present: |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
413 return check_klass(k); |
| 0 | 414 } |
| 415 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
416 static bool initialize_wk_klass(WKID id, int init_opt, TRAPS); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
417 static void initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
418 static void initialize_wk_klasses_through(WKID end_id, WKID &start_id, TRAPS) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
419 int limit = (int)end_id + 1; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
420 initialize_wk_klasses_until((WKID) limit, start_id, THREAD); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
421 } |
| 0 | 422 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
423 public: |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
424 #define WK_KLASS_DECLARE(name, ignore_symbol, option) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
425 static klassOop name() { return check_klass_##option(_well_known_klasses[WK_KLASS_ENUM_NAME(name)]); } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
426 WK_KLASSES_DO(WK_KLASS_DECLARE); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
427 #undef WK_KLASS_DECLARE |
| 0 | 428 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
429 // Local definition for direct access to the private array: |
| 147 | 430 #define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)] |
| 0 | 431 |
| 432 static klassOop box_klass(BasicType t) { | |
| 433 assert((uint)t < T_VOID+1, "range check"); | |
| 434 return check_klass(_box_klasses[t]); | |
| 435 } | |
| 436 static BasicType box_klass_type(klassOop k); // inverse of box_klass | |
| 437 | |
| 438 // methods returning lazily loaded klasses | |
| 439 // The corresponding method to load the class must be called before calling them. | |
| 440 static klassOop abstract_ownable_synchronizer_klass() { return check_klass(_abstract_ownable_synchronizer_klass); } | |
| 441 | |
| 442 static void load_abstract_ownable_synchronizer_klass(TRAPS); | |
| 443 | |
| 444 private: | |
| 445 // Tells whether ClassLoader.loadClassInternal is present | |
| 446 static bool has_loadClassInternal() { return _has_loadClassInternal; } | |
| 447 | |
| 448 public: | |
| 449 // Tells whether ClassLoader.checkPackageAccess is present | |
| 450 static bool has_checkPackageAccess() { return _has_checkPackageAccess; } | |
| 451 | |
| 1142 | 452 static bool Class_klass_loaded() { return WK_KLASS(Class_klass) != NULL; } |
| 453 static bool Cloneable_klass_loaded() { return WK_KLASS(Cloneable_klass) != NULL; } | |
| 0 | 454 |
| 455 // Returns default system loader | |
| 456 static oop java_system_loader(); | |
| 457 | |
| 458 // Compute the default system loader | |
| 459 static void compute_java_system_loader(TRAPS); | |
| 460 | |
| 461 private: | |
| 462 // Mirrors for primitive classes (created eagerly) | |
| 463 static oop check_mirror(oop m) { | |
| 464 assert(m != NULL, "mirror not initialized"); | |
| 465 return m; | |
| 466 } | |
| 467 | |
| 468 public: | |
| 469 // Note: java_lang_Class::primitive_type is the inverse of java_mirror | |
| 470 | |
| 471 // Check class loader constraints | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
472 static bool add_loader_constraint(Symbol* name, Handle loader1, |
| 0 | 473 Handle loader2, TRAPS); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
474 static char* check_signature_loaders(Symbol* signature, Handle loader1, |
| 0 | 475 Handle loader2, bool is_method, TRAPS); |
| 476 | |
| 710 | 477 // JSR 292 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
478 // find the java.lang.invoke.MethodHandles::invoke method for a given signature |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
479 static methodOop find_method_handle_invoke(Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
480 Symbol* signature, |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
481 KlassHandle accessing_klass, |
| 710 | 482 TRAPS); |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
483 // ask Java to compute a java.lang.invoke.MethodType object for a given signature |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
484 static Handle find_method_handle_type(Symbol* signature, |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
485 KlassHandle accessing_klass, |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
486 bool for_invokeGeneric, |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
487 bool& return_bcp_flag, |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
488 TRAPS); |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
489 // ask Java to compute a java.lang.invoke.MethodHandle object for a given CP entry |
| 1602 | 490 static Handle link_method_handle_constant(KlassHandle caller, |
| 491 int ref_kind, //e.g., JVM_REF_invokeVirtual | |
| 492 KlassHandle callee, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
493 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
494 Symbol* signature, |
| 1602 | 495 TRAPS); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
496 // ask Java to create a dynamic call site, while linking an invokedynamic op |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
497 static Handle make_dynamic_call_site(Handle bootstrap_method, |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
498 // Callee information: |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
499 Symbol* name, |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
500 methodHandle signature_invoker, |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
501 Handle info, |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
502 // Caller information: |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1152
diff
changeset
|
503 methodHandle caller_method, |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
504 int caller_bci, |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
505 TRAPS); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
506 |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
507 // coordinate with Java about bootstrap methods |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
508 static Handle find_bootstrap_method(methodHandle caller_method, |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
509 int caller_bci, // N.B. must be an invokedynamic |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
510 int cache_index, // must be corresponding main_entry |
|
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1793
diff
changeset
|
511 Handle &argument_info_result, // static BSM arguments, if any |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
512 TRAPS); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
513 |
| 0 | 514 // Utility for printing loader "name" as part of tracing constraints |
| 515 static const char* loader_name(oop loader) { | |
| 516 return ((loader) == NULL ? "<bootloader>" : | |
| 517 instanceKlass::cast((loader)->klass())->name()->as_C_string() ); | |
| 518 } | |
| 519 | |
| 520 // Record the error when the first attempt to resolve a reference from a constant | |
| 521 // pool entry to a class fails. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
522 static void add_resolution_error(constantPoolHandle pool, int which, Symbol* error); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
523 static Symbol* find_resolution_error(constantPoolHandle pool, int which); |
| 0 | 524 |
| 525 private: | |
| 526 | |
| 527 enum Constants { | |
| 528 _loader_constraint_size = 107, // number of entries in constraint table | |
| 529 _resolution_error_size = 107, // number of entries in resolution error table | |
| 710 | 530 _invoke_method_size = 139, // number of entries in invoke method table |
| 0 | 531 _nof_buckets = 1009 // number of buckets in hash table |
| 532 }; | |
| 533 | |
| 534 | |
| 535 // Static variables | |
| 536 | |
| 537 // Hashtable holding loaded classes. | |
| 538 static Dictionary* _dictionary; | |
| 539 | |
| 540 // Hashtable holding placeholders for classes being loaded. | |
| 541 static PlaceholderTable* _placeholders; | |
| 542 | |
| 543 // Hashtable holding classes from the shared archive. | |
| 544 static Dictionary* _shared_dictionary; | |
| 545 | |
| 546 // Monotonically increasing counter which grows with | |
| 547 // _number_of_classes as well as hot-swapping and breakpoint setting | |
| 548 // and removal. | |
| 549 static int _number_of_modifications; | |
| 550 | |
| 551 // Lock object for system class loader | |
| 552 static oop _system_loader_lock_obj; | |
| 553 | |
| 554 // Constraints on class loaders | |
| 555 static LoaderConstraintTable* _loader_constraints; | |
| 556 | |
| 557 // Resolution errors | |
| 558 static ResolutionErrorTable* _resolution_errors; | |
| 559 | |
| 710 | 560 // Invoke methods (JSR 292) |
| 561 static SymbolPropertyTable* _invoke_method_table; | |
| 562 | |
| 0 | 563 public: |
| 564 // for VM_CounterDecay iteration support | |
| 565 friend class CounterDecay; | |
| 566 static klassOop try_get_next_class(); | |
| 567 | |
| 568 private: | |
| 569 static void validate_protection_domain(instanceKlassHandle klass, | |
| 570 Handle class_loader, | |
| 571 Handle protection_domain, TRAPS); | |
| 572 | |
| 573 friend class VM_PopulateDumpSharedSpace; | |
| 574 friend class TraversePlaceholdersClosure; | |
| 575 static Dictionary* dictionary() { return _dictionary; } | |
| 576 static Dictionary* shared_dictionary() { return _shared_dictionary; } | |
| 577 static PlaceholderTable* placeholders() { return _placeholders; } | |
| 578 static LoaderConstraintTable* constraints() { return _loader_constraints; } | |
| 579 static ResolutionErrorTable* resolution_errors() { return _resolution_errors; } | |
| 710 | 580 static SymbolPropertyTable* invoke_method_table() { return _invoke_method_table; } |
| 0 | 581 |
| 582 // Basic loading operations | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
583 static klassOop resolve_instance_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
584 static klassOop resolve_array_class_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
585 static instanceKlassHandle handle_parallel_super_load(Symbol* class_name, Symbol* supername, Handle class_loader, Handle protection_domain, Handle lockObject, TRAPS); |
| 0 | 586 // Wait on SystemDictionary_lock; unlocks lockObject before |
| 587 // waiting; relocks lockObject with correct recursion count | |
| 588 // after waiting, but before reentering SystemDictionary_lock | |
| 589 // to preserve lock order semantics. | |
| 590 static void double_lock_wait(Handle lockObject, TRAPS); | |
| 591 static void define_instance_class(instanceKlassHandle k, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
592 static instanceKlassHandle find_or_define_instance_class(Symbol* class_name, |
| 0 | 593 Handle class_loader, |
| 594 instanceKlassHandle k, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
595 static instanceKlassHandle load_shared_class(Symbol* class_name, |
| 0 | 596 Handle class_loader, TRAPS); |
| 597 static instanceKlassHandle load_shared_class(instanceKlassHandle ik, | |
| 598 Handle class_loader, TRAPS); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
599 static instanceKlassHandle load_instance_class(Symbol* class_name, Handle class_loader, TRAPS); |
| 0 | 600 static Handle compute_loader_lock_object(Handle class_loader, TRAPS); |
| 601 static void check_loader_lock_contention(Handle loader_lock, TRAPS); | |
| 514 | 602 static bool is_parallelCapable(Handle class_loader); |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
973
diff
changeset
|
603 static bool is_parallelDefine(Handle class_loader); |
| 0 | 604 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
605 static klassOop find_shared_class(Symbol* class_name); |
| 0 | 606 |
| 607 // Setup link to hierarchy | |
| 608 static void add_to_hierarchy(instanceKlassHandle k, TRAPS); | |
| 609 | |
| 610 private: | |
| 611 // We pass in the hashtable index so we can calculate it outside of | |
| 612 // the SystemDictionary_lock. | |
| 613 | |
| 614 // Basic find on loaded classes | |
| 615 static klassOop find_class(int index, unsigned int hash, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
616 Symbol* name, Handle loader); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
617 static klassOop find_class(Symbol* class_name, Handle class_loader); |
| 0 | 618 |
| 619 // Basic find on classes in the midst of being loaded | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
620 static Symbol* find_placeholder(Symbol* name, Handle loader); |
| 0 | 621 |
| 622 // Updating entry in dictionary | |
| 623 // Add a completely loaded class | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
624 static void add_klass(int index, Symbol* class_name, |
| 0 | 625 Handle class_loader, KlassHandle obj); |
| 626 | |
| 627 // Add a placeholder for a class being loaded | |
| 628 static void add_placeholder(int index, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
629 Symbol* class_name, |
| 0 | 630 Handle class_loader); |
| 631 static void remove_placeholder(int index, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
632 Symbol* class_name, |
| 0 | 633 Handle class_loader); |
| 634 | |
| 635 // Performs cleanups after resolve_super_or_fail. This typically needs | |
| 636 // to be called on failure. | |
| 637 // Won't throw, but can block. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2129
diff
changeset
|
638 static void resolution_cleanups(Symbol* class_name, |
| 0 | 639 Handle class_loader, |
| 640 TRAPS); | |
| 641 | |
| 642 // Initialization | |
| 643 static void initialize_preloaded_classes(TRAPS); | |
| 644 | |
| 645 // Class loader constraints | |
| 646 static void check_constraints(int index, unsigned int hash, | |
| 647 instanceKlassHandle k, Handle loader, | |
| 648 bool defining, TRAPS); | |
| 649 static void update_dictionary(int d_index, unsigned int d_hash, | |
| 650 int p_index, unsigned int p_hash, | |
| 651 instanceKlassHandle k, Handle loader, TRAPS); | |
| 652 | |
| 653 // Variables holding commonly used klasses (preloaded) | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
654 static klassOop _well_known_klasses[]; |
| 0 | 655 |
| 656 // Lazily loaded klasses | |
| 657 static volatile klassOop _abstract_ownable_synchronizer_klass; | |
| 658 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
0
diff
changeset
|
659 // table of box klasses (int_klass, etc.) |
| 0 | 660 static klassOop _box_klasses[T_VOID+1]; |
| 661 | |
| 662 static oop _java_system_loader; | |
| 663 | |
| 664 static bool _has_loadClassInternal; | |
| 665 static bool _has_checkPackageAccess; | |
| 666 }; | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
667 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
668 class SystemDictionaryHandles : AllStatic { |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
669 public: |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
670 #define WK_KLASS_HANDLE_DECLARE(name, ignore_symbol, option) \ |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
671 static KlassHandle name() { \ |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
672 SystemDictionary::name(); \ |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
673 klassOop* loc = &SystemDictionary::_well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]; \ |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
674 return KlassHandle(loc, true); \ |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
675 } |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
676 WK_KLASSES_DO(WK_KLASS_HANDLE_DECLARE); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
677 #undef WK_KLASS_HANDLE_DECLARE |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
678 |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
679 static KlassHandle box_klass(BasicType t); |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
680 }; |
| 1972 | 681 |
| 682 #endif // SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP |