Mercurial > hg > graal-compiler
annotate src/share/vm/classfile/systemDictionary.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | 633ba56cb013 |
| children | e522a00b91aa 070d523b96a7 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4864
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
2 * Copyright (c) 1997, 2012, 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 #include "precompiled.hpp" |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
26 #include "classfile/classLoaderData.inline.hpp" |
| 1972 | 27 #include "classfile/dictionary.hpp" |
| 28 #include "classfile/javaClasses.hpp" | |
| 29 #include "classfile/loaderConstraints.hpp" | |
| 30 #include "classfile/placeholders.hpp" | |
| 31 #include "classfile/resolutionErrors.hpp" | |
| 32 #include "classfile/systemDictionary.hpp" | |
| 33 #include "classfile/vmSymbols.hpp" | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
34 #include "compiler/compileBroker.hpp" |
| 1972 | 35 #include "interpreter/bytecodeStream.hpp" |
| 36 #include "interpreter/interpreter.hpp" | |
| 37 #include "memory/gcLocker.hpp" | |
| 38 #include "memory/oopFactory.hpp" | |
| 39 #include "oops/instanceKlass.hpp" | |
| 40 #include "oops/instanceRefKlass.hpp" | |
| 41 #include "oops/klass.inline.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
42 #include "oops/methodData.hpp" |
| 1972 | 43 #include "oops/objArrayKlass.hpp" |
| 44 #include "oops/oop.inline.hpp" | |
| 45 #include "oops/oop.inline2.hpp" | |
| 46 #include "oops/typeArrayKlass.hpp" | |
| 47 #include "prims/jvmtiEnvBase.hpp" | |
| 48 #include "prims/methodHandles.hpp" | |
| 49 #include "runtime/biasedLocking.hpp" | |
| 50 #include "runtime/fieldType.hpp" | |
| 51 #include "runtime/handles.inline.hpp" | |
| 52 #include "runtime/java.hpp" | |
| 53 #include "runtime/javaCalls.hpp" | |
| 54 #include "runtime/mutexLocker.hpp" | |
| 55 #include "runtime/signature.hpp" | |
| 56 #include "services/classLoadingService.hpp" | |
| 57 #include "services/threadService.hpp" | |
| 0 | 58 |
| 59 | |
| 1903 | 60 Dictionary* SystemDictionary::_dictionary = NULL; |
| 61 PlaceholderTable* SystemDictionary::_placeholders = NULL; | |
| 62 Dictionary* SystemDictionary::_shared_dictionary = NULL; | |
| 63 LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL; | |
| 64 ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL; | |
| 65 SymbolPropertyTable* SystemDictionary::_invoke_method_table = NULL; | |
| 0 | 66 |
| 67 | |
| 68 int SystemDictionary::_number_of_modifications = 0; | |
|
4864
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
69 int SystemDictionary::_sdgeneration = 0; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
70 const int SystemDictionary::_primelist[_prime_array_size] = {1009,2017,4049,5051,10103, |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
71 20201,40423,99991}; |
| 0 | 72 |
| 73 oop SystemDictionary::_system_loader_lock_obj = NULL; | |
| 74 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
75 Klass* SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT] |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
76 = { NULL /*, NULL...*/ }; |
| 0 | 77 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
78 Klass* SystemDictionary::_box_klasses[T_VOID+1] = { NULL /*, NULL...*/ }; |
| 0 | 79 |
| 80 oop SystemDictionary::_java_system_loader = NULL; | |
| 81 | |
| 82 bool SystemDictionary::_has_loadClassInternal = false; | |
| 83 bool SystemDictionary::_has_checkPackageAccess = false; | |
| 84 | |
| 85 // lazily initialized klass variables | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
86 Klass* volatile SystemDictionary::_abstract_ownable_synchronizer_klass = NULL; |
| 0 | 87 |
| 88 | |
| 89 // ---------------------------------------------------------------------------- | |
| 90 // Java-level SystemLoader | |
| 91 | |
| 92 oop SystemDictionary::java_system_loader() { | |
| 93 return _java_system_loader; | |
| 94 } | |
| 95 | |
| 96 void SystemDictionary::compute_java_system_loader(TRAPS) { | |
| 1142 | 97 KlassHandle system_klass(THREAD, WK_KLASS(ClassLoader_klass)); |
| 0 | 98 JavaValue result(T_OBJECT); |
| 99 JavaCalls::call_static(&result, | |
| 1142 | 100 KlassHandle(THREAD, WK_KLASS(ClassLoader_klass)), |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
101 vmSymbols::getSystemClassLoader_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
102 vmSymbols::void_classloader_signature(), |
| 0 | 103 CHECK); |
| 104 | |
| 105 _java_system_loader = (oop)result.get_jobject(); | |
| 106 } | |
| 107 | |
| 108 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
109 ClassLoaderData* SystemDictionary::register_loader(Handle class_loader) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
110 if (class_loader() == NULL) return ClassLoaderData::the_null_class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
111 return ClassLoaderDataGraph::find_or_create(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
112 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
113 |
| 0 | 114 // ---------------------------------------------------------------------------- |
| 115 // debugging | |
| 116 | |
| 117 #ifdef ASSERT | |
| 118 | |
| 119 // return true if class_name contains no '.' (internal format is '/') | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
120 bool SystemDictionary::is_internal_format(Symbol* class_name) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
121 if (class_name != NULL) { |
| 0 | 122 ResourceMark rm; |
| 123 char* name = class_name->as_C_string(); | |
| 124 return strchr(name, '.') == NULL; | |
| 125 } else { | |
| 126 return true; | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 #endif | |
| 131 | |
| 132 // ---------------------------------------------------------------------------- | |
| 514 | 133 // Parallel class loading check |
| 134 | |
| 135 bool SystemDictionary::is_parallelCapable(Handle class_loader) { | |
| 136 if (UnsyncloadClass || class_loader.is_null()) return true; | |
| 137 if (AlwaysLockClassLoader) return false; | |
| 3938 | 138 return java_lang_ClassLoader::parallelCapable(class_loader()); |
| 514 | 139 } |
| 140 // ---------------------------------------------------------------------------- | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
141 // ParallelDefineClass flag does not apply to bootclass loader |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
142 bool SystemDictionary::is_parallelDefine(Handle class_loader) { |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
143 if (class_loader.is_null()) return false; |
| 3938 | 144 if (AllowParallelDefineClass && java_lang_ClassLoader::parallelCapable(class_loader())) { |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
145 return true; |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
146 } |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
147 return false; |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
148 } |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
149 // ---------------------------------------------------------------------------- |
| 0 | 150 // Resolving of classes |
| 151 | |
| 152 // Forwards to resolve_or_null | |
| 153 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
154 Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
155 Klass* klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD); |
| 0 | 156 if (HAS_PENDING_EXCEPTION || klass == NULL) { |
| 157 KlassHandle k_h(THREAD, klass); | |
| 158 // can return a null klass | |
| 159 klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD); | |
| 160 } | |
| 161 return klass; | |
| 162 } | |
| 163 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
164 Klass* SystemDictionary::handle_resolution_exception(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) { |
| 0 | 165 if (HAS_PENDING_EXCEPTION) { |
| 166 // If we have a pending exception we forward it to the caller, unless throw_error is true, | |
| 167 // in which case we have to check whether the pending exception is a ClassNotFoundException, | |
| 168 // and if so convert it to a NoClassDefFoundError | |
| 169 // And chain the original ClassNotFoundException | |
| 1142 | 170 if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass())) { |
| 0 | 171 ResourceMark rm(THREAD); |
| 172 assert(klass_h() == NULL, "Should not have result with exception pending"); | |
| 173 Handle e(THREAD, PENDING_EXCEPTION); | |
| 174 CLEAR_PENDING_EXCEPTION; | |
| 175 THROW_MSG_CAUSE_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e); | |
| 176 } else { | |
| 177 return NULL; | |
| 178 } | |
| 179 } | |
| 180 // Class not found, throw appropriate error or exception depending on value of throw_error | |
| 181 if (klass_h() == NULL) { | |
| 182 ResourceMark rm(THREAD); | |
| 183 if (throw_error) { | |
| 184 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string()); | |
| 185 } else { | |
| 186 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string()); | |
| 187 } | |
| 188 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 return (Klass*)klass_h(); |
| 0 | 190 } |
| 191 | |
| 192 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
193 Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, |
| 0 | 194 bool throw_error, TRAPS) |
| 195 { | |
| 196 return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD); | |
| 197 } | |
| 198 | |
| 199 | |
| 200 // Forwards to resolve_instance_class_or_null | |
| 201 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
202 Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
203 assert(!THREAD->is_Compiler_thread(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
204 err_msg("can not load classes with compiler thread: class=%s, classloader=%s", |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
205 class_name->as_C_string(), |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
206 class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string())); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
207 if (FieldType::is_array(class_name)) { |
| 0 | 208 return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
209 } else if (FieldType::is_obj(class_name)) { |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
210 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
211 // Ignore wrapping L and ;. |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
212 TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
213 class_name->utf8_length() - 2, CHECK_NULL); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
214 return resolve_instance_class_or_null(name, class_loader, protection_domain, CHECK_NULL); |
| 0 | 215 } else { |
| 216 return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL); | |
| 217 } | |
| 218 } | |
| 219 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
220 Klass* SystemDictionary::resolve_or_null(Symbol* class_name, TRAPS) { |
| 0 | 221 return resolve_or_null(class_name, Handle(), Handle(), THREAD); |
| 222 } | |
| 223 | |
| 224 // Forwards to resolve_instance_class_or_null | |
| 225 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
226 Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name, |
| 0 | 227 Handle class_loader, |
| 228 Handle protection_domain, | |
| 229 TRAPS) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
230 assert(FieldType::is_array(class_name), "must be array"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
231 Klass* k = NULL; |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
232 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
233 // dimension and object_key in FieldArrayInfo are assigned as a side-effect |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
234 // of this call |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
235 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_NULL); |
| 0 | 236 if (t == T_OBJECT) { |
| 237 // naked oop "k" is OK here -- we assign back into it | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
238 k = SystemDictionary::resolve_instance_class_or_null(fd.object_key(), |
| 0 | 239 class_loader, |
| 240 protection_domain, | |
| 241 CHECK_NULL); | |
| 242 if (k != NULL) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
243 k = Klass::cast(k)->array_klass(fd.dimension(), CHECK_NULL); |
| 0 | 244 } |
| 245 } else { | |
| 246 k = Universe::typeArrayKlassObj(t); | |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
247 k = TypeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL); |
| 0 | 248 } |
| 249 return k; | |
| 250 } | |
| 251 | |
| 252 | |
| 253 // Must be called for any super-class or super-interface resolution | |
| 254 // during class definition to allow class circularity checking | |
| 255 // super-interface callers: | |
| 256 // parse_interfaces - for defineClass & jvmtiRedefineClasses | |
| 257 // super-class callers: | |
| 258 // ClassFileParser - for defineClass & jvmtiRedefineClasses | |
| 259 // load_shared_class - while loading a class from shared archive | |
| 514 | 260 // resolve_instance_class_or_null: |
| 261 // via: handle_parallel_super_load | |
| 0 | 262 // when resolving a class that has an existing placeholder with |
| 263 // a saved superclass [i.e. a defineClass is currently in progress] | |
| 264 // if another thread is trying to resolve the class, it must do | |
| 265 // super-class checks on its own thread to catch class circularity | |
| 266 // This last call is critical in class circularity checking for cases | |
| 267 // where classloading is delegated to different threads and the | |
| 268 // classloader lock is released. | |
| 269 // Take the case: Base->Super->Base | |
| 270 // 1. If thread T1 tries to do a defineClass of class Base | |
| 271 // resolve_super_or_fail creates placeholder: T1, Base (super Super) | |
| 272 // 2. resolve_instance_class_or_null does not find SD or placeholder for Super | |
| 273 // so it tries to load Super | |
| 274 // 3. If we load the class internally, or user classloader uses same thread | |
| 275 // loadClassFromxxx or defineClass via parseClassFile Super ... | |
| 276 // 3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base) | |
| 277 // 3.3 resolve_instance_class_or_null Base, finds placeholder for Base | |
| 278 // 3.4 calls resolve_super_or_fail Base | |
| 279 // 3.5 finds T1,Base -> throws class circularity | |
| 280 //OR 4. If T2 tries to resolve Super via defineClass Super ... | |
| 281 // 4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base) | |
| 282 // 4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super) | |
| 283 // 4.3 calls resolve_super_or_fail Super in parallel on own thread T2 | |
| 284 // 4.4 finds T2, Super -> throws class circularity | |
| 285 // Must be called, even if superclass is null, since this is | |
| 286 // where the placeholder entry is created which claims this | |
| 287 // thread is loading this class/classloader. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
288 Klass* SystemDictionary::resolve_super_or_fail(Symbol* child_name, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
289 Symbol* class_name, |
| 0 | 290 Handle class_loader, |
| 291 Handle protection_domain, | |
| 292 bool is_superclass, | |
| 293 TRAPS) { | |
| 294 // Double-check, if child class is already loaded, just return super-class,interface | |
| 295 // Don't add a placedholder if already loaded, i.e. already in system dictionary | |
| 296 // Make sure there's a placeholder for the *child* before resolving. | |
| 297 // Used as a claim that this thread is currently loading superclass/classloader | |
| 298 // Used here for ClassCircularity checks and also for heap verification | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
299 // (every InstanceKlass in the heap needs to be in the system dictionary |
| 0 | 300 // or have a placeholder). |
| 301 // Must check ClassCircularity before checking if super class is already loaded | |
| 302 // | |
| 303 // We might not already have a placeholder if this child_name was | |
| 304 // first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass); | |
| 305 // the name of the class might not be known until the stream is actually | |
| 306 // parsed. | |
| 307 // Bugs 4643874, 4715493 | |
| 308 // compute_hash can have a safepoint | |
| 309 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
310 ClassLoaderData* loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
311 unsigned int d_hash = dictionary()->compute_hash(child_name, loader_data); |
| 0 | 312 int d_index = dictionary()->hash_to_index(d_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
313 unsigned int p_hash = placeholders()->compute_hash(child_name, loader_data); |
| 0 | 314 int p_index = placeholders()->hash_to_index(p_hash); |
| 315 // can't throw error holding a lock | |
| 316 bool child_already_loaded = false; | |
| 317 bool throw_circularity_error = false; | |
| 318 { | |
| 319 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
320 Klass* childk = find_class(d_index, d_hash, child_name, loader_data); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
321 Klass* quicksuperk; |
| 0 | 322 // to support // loading: if child done loading, just return superclass |
| 323 // if class_name, & class_loader don't match: | |
| 324 // if initial define, SD update will give LinkageError | |
| 325 // if redefine: compare_class_versions will give HIERARCHY_CHANGED | |
| 326 // so we don't throw an exception here. | |
| 327 // see: nsk redefclass014 & java.lang.instrument Instrument032 | |
| 328 if ((childk != NULL ) && (is_superclass) && | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
329 ((quicksuperk = InstanceKlass::cast(childk)->super()) != NULL) && |
| 0 | 330 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
331 ((Klass::cast(quicksuperk)->name() == class_name) && |
| 0 | 332 (Klass::cast(quicksuperk)->class_loader() == class_loader()))) { |
| 333 return quicksuperk; | |
| 334 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
335 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data); |
| 0 | 336 if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) { |
| 337 throw_circularity_error = true; | |
| 338 } | |
| 514 | 339 } |
| 340 if (!throw_circularity_error) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
341 PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, class_name, THREAD); |
| 0 | 342 } |
| 343 } | |
| 344 if (throw_circularity_error) { | |
| 345 ResourceMark rm(THREAD); | |
| 346 THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string()); | |
| 347 } | |
| 348 | |
| 349 // java.lang.Object should have been found above | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
350 assert(class_name != NULL, "null super class for resolving"); |
| 0 | 351 // Resolve the super class or interface, check results on return |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
352 Klass* superk = NULL; |
| 0 | 353 superk = SystemDictionary::resolve_or_null(class_name, |
| 354 class_loader, | |
| 355 protection_domain, | |
| 356 THREAD); | |
| 357 | |
| 358 KlassHandle superk_h(THREAD, superk); | |
| 359 | |
| 360 // Note: clean up of placeholders currently in callers of | |
| 361 // resolve_super_or_fail - either at update_dictionary time | |
| 362 // or on error | |
| 363 { | |
| 364 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
365 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data); |
| 0 | 366 if (probe != NULL) { |
| 367 probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER); | |
| 368 } | |
| 369 } | |
| 370 if (HAS_PENDING_EXCEPTION || superk_h() == NULL) { | |
| 371 // can null superk | |
| 372 superk_h = KlassHandle(THREAD, handle_resolution_exception(class_name, class_loader, protection_domain, true, superk_h, THREAD)); | |
| 373 } | |
| 374 | |
| 375 return superk_h(); | |
| 376 } | |
| 377 | |
| 378 void SystemDictionary::validate_protection_domain(instanceKlassHandle klass, | |
| 379 Handle class_loader, | |
| 380 Handle protection_domain, | |
| 381 TRAPS) { | |
| 382 if(!has_checkPackageAccess()) return; | |
| 383 | |
| 384 // Now we have to call back to java to check if the initating class has access | |
| 385 JavaValue result(T_VOID); | |
| 386 if (TraceProtectionDomainVerification) { | |
| 387 // Print out trace information | |
| 388 tty->print_cr("Checking package access"); | |
| 389 tty->print(" - class loader: "); class_loader()->print_value_on(tty); tty->cr(); | |
| 390 tty->print(" - protection domain: "); protection_domain()->print_value_on(tty); tty->cr(); | |
| 391 tty->print(" - loading: "); klass()->print_value_on(tty); tty->cr(); | |
| 392 } | |
| 393 | |
| 1142 | 394 KlassHandle system_loader(THREAD, SystemDictionary::ClassLoader_klass()); |
| 0 | 395 JavaCalls::call_special(&result, |
| 396 class_loader, | |
| 397 system_loader, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
398 vmSymbols::checkPackageAccess_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
399 vmSymbols::class_protectiondomain_signature(), |
| 0 | 400 Handle(THREAD, klass->java_mirror()), |
| 401 protection_domain, | |
| 402 THREAD); | |
| 403 | |
| 404 if (TraceProtectionDomainVerification) { | |
| 405 if (HAS_PENDING_EXCEPTION) { | |
| 406 tty->print_cr(" -> DENIED !!!!!!!!!!!!!!!!!!!!!"); | |
| 407 } else { | |
| 408 tty->print_cr(" -> granted"); | |
| 409 } | |
| 410 tty->cr(); | |
| 411 } | |
| 412 | |
| 413 if (HAS_PENDING_EXCEPTION) return; | |
| 414 | |
| 415 // If no exception has been thrown, we have validated the protection domain | |
| 416 // Insert the protection domain of the initiating class into the set. | |
| 417 { | |
| 418 // We recalculate the entry here -- we've called out to java since | |
| 419 // the last time it was calculated. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
420 ClassLoaderData* loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
421 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
422 Symbol* kn = klass->name(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
423 unsigned int d_hash = dictionary()->compute_hash(kn, loader_data); |
| 0 | 424 int d_index = dictionary()->hash_to_index(d_hash); |
| 425 | |
| 426 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 427 { | |
| 428 // Note that we have an entry, and entries can be deleted only during GC, | |
| 429 // so we cannot allow GC to occur while we're holding this entry. | |
| 430 | |
| 431 // We're using a No_Safepoint_Verifier to catch any place where we | |
| 432 // might potentially do a GC at all. | |
| 433 // SystemDictionary::do_unloading() asserts that classes are only | |
| 434 // unloaded at a safepoint. | |
| 435 No_Safepoint_Verifier nosafepoint; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
436 dictionary()->add_protection_domain(d_index, d_hash, klass, loader_data, |
| 0 | 437 protection_domain, THREAD); |
| 438 } | |
| 439 } | |
| 440 } | |
| 441 | |
| 442 // We only get here if this thread finds that another thread | |
| 443 // has already claimed the placeholder token for the current operation, | |
| 444 // but that other thread either never owned or gave up the | |
| 445 // object lock | |
| 446 // Waits on SystemDictionary_lock to indicate placeholder table updated | |
| 447 // On return, caller must recheck placeholder table state | |
| 448 // | |
| 449 // We only get here if | |
| 450 // 1) custom classLoader, i.e. not bootstrap classloader | |
| 451 // 2) UnsyncloadClass not set | |
| 452 // 3) custom classLoader has broken the class loader objectLock | |
| 453 // so another thread got here in parallel | |
| 454 // | |
| 455 // lockObject must be held. | |
| 456 // Complicated dance due to lock ordering: | |
| 457 // Must first release the classloader object lock to | |
| 458 // allow initial definer to complete the class definition | |
| 459 // and to avoid deadlock | |
| 460 // Reclaim classloader lock object with same original recursion count | |
| 461 // Must release SystemDictionary_lock after notify, since | |
| 462 // class loader lock must be claimed before SystemDictionary_lock | |
| 463 // to prevent deadlocks | |
| 464 // | |
| 465 // The notify allows applications that did an untimed wait() on | |
| 466 // the classloader object lock to not hang. | |
| 467 void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) { | |
| 468 assert_lock_strong(SystemDictionary_lock); | |
| 469 | |
| 470 bool calledholdinglock | |
| 471 = ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject); | |
| 472 assert(calledholdinglock,"must hold lock for notify"); | |
| 514 | 473 assert((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait"); |
| 0 | 474 ObjectSynchronizer::notifyall(lockObject, THREAD); |
| 475 intptr_t recursions = ObjectSynchronizer::complete_exit(lockObject, THREAD); | |
| 476 SystemDictionary_lock->wait(); | |
| 477 SystemDictionary_lock->unlock(); | |
| 478 ObjectSynchronizer::reenter(lockObject, recursions, THREAD); | |
| 479 SystemDictionary_lock->lock(); | |
| 480 } | |
| 481 | |
| 482 // If the class in is in the placeholder table, class loading is in progress | |
| 483 // For cases where the application changes threads to load classes, it | |
| 484 // is critical to ClassCircularity detection that we try loading | |
| 485 // the superclass on the same thread internally, so we do parallel | |
| 486 // super class loading here. | |
| 487 // This also is critical in cases where the original thread gets stalled | |
| 488 // even in non-circularity situations. | |
| 489 // Note: only one thread can define the class, but multiple can resolve | |
| 490 // Note: must call resolve_super_or_fail even if null super - | |
| 514 | 491 // to force placeholder entry creation for this class for circularity detection |
| 0 | 492 // Caller must check for pending exception |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
493 // Returns non-null Klass* if other thread has completed load |
| 0 | 494 // and we are done, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
495 // If return null Klass* and no pending exception, the caller must load the class |
| 0 | 496 instanceKlassHandle SystemDictionary::handle_parallel_super_load( |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
497 Symbol* name, Symbol* superclassname, Handle class_loader, |
| 0 | 498 Handle protection_domain, Handle lockObject, TRAPS) { |
| 499 | |
| 500 instanceKlassHandle nh = instanceKlassHandle(); // null Handle | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
501 ClassLoaderData* loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
502 unsigned int d_hash = dictionary()->compute_hash(name, loader_data); |
| 0 | 503 int d_index = dictionary()->hash_to_index(d_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
504 unsigned int p_hash = placeholders()->compute_hash(name, loader_data); |
| 0 | 505 int p_index = placeholders()->hash_to_index(p_hash); |
| 506 | |
| 507 // superk is not used, resolve_super called for circularity check only | |
| 508 // This code is reached in two situations. One if this thread | |
| 509 // is loading the same class twice (e.g. ClassCircularity, or | |
| 510 // java.lang.instrument). | |
| 511 // The second is if another thread started the resolve_super first | |
| 512 // and has not yet finished. | |
| 513 // In both cases the original caller will clean up the placeholder | |
| 514 // entry on error. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
515 Klass* superk = SystemDictionary::resolve_super_or_fail(name, |
| 0 | 516 superclassname, |
| 517 class_loader, | |
| 518 protection_domain, | |
| 519 true, | |
| 520 CHECK_(nh)); | |
| 521 // We don't redefine the class, so we just need to clean up if there | |
| 522 // was not an error (don't want to modify any system dictionary | |
| 523 // data structures). | |
| 524 { | |
| 525 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
526 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
| 0 | 527 SystemDictionary_lock->notify_all(); |
| 528 } | |
| 529 | |
| 514 | 530 // parallelCapable class loaders do NOT wait for parallel superclass loads to complete |
| 531 // Serial class loaders and bootstrap classloader do wait for superclass loads | |
| 532 if (!class_loader.is_null() && is_parallelCapable(class_loader)) { | |
| 0 | 533 MutexLocker mu(SystemDictionary_lock, THREAD); |
| 534 // Check if classloading completed while we were loading superclass or waiting | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
535 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 536 if (check != NULL) { |
| 537 // Klass is already loaded, so just return it | |
| 538 return(instanceKlassHandle(THREAD, check)); | |
| 539 } else { | |
| 540 return nh; | |
| 541 } | |
| 542 } | |
| 543 | |
| 544 // must loop to both handle other placeholder updates | |
| 545 // and spurious notifications | |
| 546 bool super_load_in_progress = true; | |
| 547 PlaceholderEntry* placeholder; | |
| 548 while (super_load_in_progress) { | |
| 549 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 550 // Check if classloading completed while we were loading superclass or waiting | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
551 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 552 if (check != NULL) { |
| 553 // Klass is already loaded, so just return it | |
| 554 return(instanceKlassHandle(THREAD, check)); | |
| 555 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
556 placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
| 0 | 557 if (placeholder && placeholder->super_load_in_progress() ){ |
| 558 // Before UnsyncloadClass: | |
| 559 // We only get here if the application has released the | |
| 560 // classloader lock when another thread was in the middle of loading a | |
| 561 // superclass/superinterface for this class, and now | |
| 562 // this thread is also trying to load this class. | |
| 563 // To minimize surprises, the first thread that started to | |
| 564 // load a class should be the one to complete the loading | |
| 565 // with the classfile it initially expected. | |
| 566 // This logic has the current thread wait once it has done | |
| 567 // all the superclass/superinterface loading it can, until | |
| 568 // the original thread completes the class loading or fails | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
569 // If it completes we will use the resulting InstanceKlass |
| 0 | 570 // which we will find below in the systemDictionary. |
| 571 // We also get here for parallel bootstrap classloader | |
| 572 if (class_loader.is_null()) { | |
| 573 SystemDictionary_lock->wait(); | |
| 574 } else { | |
| 575 double_lock_wait(lockObject, THREAD); | |
| 576 } | |
| 577 } else { | |
| 578 // If not in SD and not in PH, other thread's load must have failed | |
| 579 super_load_in_progress = false; | |
| 580 } | |
| 581 } | |
| 582 } | |
| 583 return (nh); | |
| 584 } | |
| 585 | |
| 586 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
587 Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name, Handle class_loader, Handle protection_domain, TRAPS) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
588 assert(name != NULL && !FieldType::is_array(name) && |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
589 !FieldType::is_obj(name), "invalid class name"); |
| 0 | 590 |
| 591 // UseNewReflection | |
| 592 // Fix for 4474172; see evaluation for more details | |
| 593 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
594 ClassLoaderData *loader_data = register_loader(class_loader); |
| 0 | 595 |
| 596 // Do lookup to see if class already exist and the protection domain | |
| 597 // has the right access | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
598 unsigned int d_hash = dictionary()->compute_hash(name, loader_data); |
| 0 | 599 int d_index = dictionary()->hash_to_index(d_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
600 Klass* probe = dictionary()->find(d_index, d_hash, name, loader_data, |
| 0 | 601 protection_domain, THREAD); |
| 602 if (probe != NULL) return probe; | |
| 603 | |
| 604 | |
| 605 // Non-bootstrap class loaders will call out to class loader and | |
| 606 // define via jvm/jni_DefineClass which will acquire the | |
| 607 // class loader object lock to protect against multiple threads | |
| 608 // defining the class in parallel by accident. | |
| 609 // This lock must be acquired here so the waiter will find | |
| 610 // any successful result in the SystemDictionary and not attempt | |
| 611 // the define | |
| 514 | 612 // ParallelCapable Classloaders and the bootstrap classloader, |
| 0 | 613 // or all classloaders with UnsyncloadClass do not acquire lock here |
| 614 bool DoObjectLock = true; | |
| 514 | 615 if (is_parallelCapable(class_loader)) { |
| 0 | 616 DoObjectLock = false; |
| 617 } | |
| 618 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
619 unsigned int p_hash = placeholders()->compute_hash(name, loader_data); |
| 0 | 620 int p_index = placeholders()->hash_to_index(p_hash); |
| 621 | |
| 622 // Class is not in SystemDictionary so we have to do loading. | |
| 623 // Make sure we are synchronized on the class loader before we proceed | |
| 624 Handle lockObject = compute_loader_lock_object(class_loader, THREAD); | |
| 625 check_loader_lock_contention(lockObject, THREAD); | |
| 626 ObjectLocker ol(lockObject, THREAD, DoObjectLock); | |
| 627 | |
| 628 // Check again (after locking) if class already exist in SystemDictionary | |
| 629 bool class_has_been_loaded = false; | |
| 630 bool super_load_in_progress = false; | |
| 631 bool havesupername = false; | |
| 632 instanceKlassHandle k; | |
| 633 PlaceholderEntry* placeholder; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
634 Symbol* superclassname = NULL; |
| 0 | 635 |
| 636 { | |
| 637 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
638 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 639 if (check != NULL) { |
| 640 // Klass is already loaded, so just return it | |
| 641 class_has_been_loaded = true; | |
| 642 k = instanceKlassHandle(THREAD, check); | |
| 643 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
644 placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
| 0 | 645 if (placeholder && placeholder->super_load_in_progress()) { |
| 646 super_load_in_progress = true; | |
| 647 if (placeholder->havesupername() == true) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
648 superclassname = placeholder->supername(); |
| 0 | 649 havesupername = true; |
| 650 } | |
| 651 } | |
| 652 } | |
| 653 } | |
| 654 | |
| 655 // If the class in is in the placeholder table, class loading is in progress | |
| 656 if (super_load_in_progress && havesupername==true) { | |
| 657 k = SystemDictionary::handle_parallel_super_load(name, superclassname, | |
| 658 class_loader, protection_domain, lockObject, THREAD); | |
| 659 if (HAS_PENDING_EXCEPTION) { | |
| 660 return NULL; | |
| 661 } | |
| 662 if (!k.is_null()) { | |
| 663 class_has_been_loaded = true; | |
| 664 } | |
| 665 } | |
| 666 | |
| 667 if (!class_has_been_loaded) { | |
| 668 | |
| 669 // add placeholder entry to record loading instance class | |
| 670 // Five cases: | |
| 671 // All cases need to prevent modifying bootclasssearchpath | |
| 672 // in parallel with a classload of same classname | |
| 514 | 673 // Redefineclasses uses existence of the placeholder for the duration |
| 674 // of the class load to prevent concurrent redefinition of not completely | |
| 675 // defined classes. | |
| 0 | 676 // case 1. traditional classloaders that rely on the classloader object lock |
| 677 // - no other need for LOAD_INSTANCE | |
| 678 // case 2. traditional classloaders that break the classloader object lock | |
| 679 // as a deadlock workaround. Detection of this case requires that | |
| 680 // this check is done while holding the classloader object lock, | |
| 681 // and that lock is still held when calling classloader's loadClass. | |
| 682 // For these classloaders, we ensure that the first requestor | |
| 683 // completes the load and other requestors wait for completion. | |
| 684 // case 3. UnsyncloadClass - don't use objectLocker | |
| 685 // With this flag, we allow parallel classloading of a | |
| 686 // class/classloader pair | |
| 687 // case4. Bootstrap classloader - don't own objectLocker | |
| 688 // This classloader supports parallelism at the classloader level, | |
| 689 // but only allows a single load of a class/classloader pair. | |
| 690 // No performance benefit and no deadlock issues. | |
| 514 | 691 // case 5. parallelCapable user level classloaders - without objectLocker |
| 692 // Allow parallel classloading of a class/classloader pair | |
| 0 | 693 bool throw_circularity_error = false; |
| 694 { | |
| 695 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 514 | 696 if (class_loader.is_null() || !is_parallelCapable(class_loader)) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
697 PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
| 0 | 698 if (oldprobe) { |
| 699 // only need check_seen_thread once, not on each loop | |
| 700 // 6341374 java/lang/Instrument with -Xcomp | |
| 701 if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) { | |
| 702 throw_circularity_error = true; | |
| 703 } else { | |
| 704 // case 1: traditional: should never see load_in_progress. | |
| 705 while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) { | |
| 706 | |
| 707 // case 4: bootstrap classloader: prevent futile classloading, | |
| 708 // wait on first requestor | |
| 709 if (class_loader.is_null()) { | |
| 710 SystemDictionary_lock->wait(); | |
| 711 } else { | |
| 712 // case 2: traditional with broken classloader lock. wait on first | |
| 713 // requestor. | |
| 714 double_lock_wait(lockObject, THREAD); | |
| 715 } | |
| 716 // Check if classloading completed while we were waiting | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
717 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 718 if (check != NULL) { |
| 719 // Klass is already loaded, so just return it | |
| 720 k = instanceKlassHandle(THREAD, check); | |
| 721 class_has_been_loaded = true; | |
| 722 } | |
| 723 // check if other thread failed to load and cleaned up | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
724 oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
| 0 | 725 } |
| 726 } | |
| 727 } | |
| 728 } | |
| 729 // All cases: add LOAD_INSTANCE | |
| 514 | 730 // case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try |
| 0 | 731 // LOAD_INSTANCE in parallel |
| 732 // add placeholder entry even if error - callers will remove on error | |
| 514 | 733 if (!throw_circularity_error && !class_has_been_loaded) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
734 PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, NULL, THREAD); |
| 0 | 735 // For class loaders that do not acquire the classloader object lock, |
| 736 // if they did not catch another thread holding LOAD_INSTANCE, | |
| 737 // need a check analogous to the acquire ObjectLocker/find_class | |
| 738 // i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL | |
| 739 // one final check if the load has already completed | |
| 514 | 740 // class loaders holding the ObjectLock shouldn't find the class here |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
741 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 742 if (check != NULL) { |
| 743 // Klass is already loaded, so just return it | |
| 744 k = instanceKlassHandle(THREAD, check); | |
| 745 class_has_been_loaded = true; | |
| 746 newprobe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
747 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
| 514 | 748 SystemDictionary_lock->notify_all(); |
| 0 | 749 } |
| 750 } | |
| 751 } | |
| 752 // must throw error outside of owning lock | |
| 753 if (throw_circularity_error) { | |
| 754 ResourceMark rm(THREAD); | |
| 755 THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string()); | |
| 756 } | |
| 757 | |
| 758 if (!class_has_been_loaded) { | |
| 759 | |
| 760 // Do actual loading | |
| 761 k = load_instance_class(name, class_loader, THREAD); | |
| 762 | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
763 // For UnsyncloadClass only |
| 0 | 764 // If they got a linkageError, check if a parallel class load succeeded. |
| 765 // If it did, then for bytecode resolution the specification requires | |
| 766 // that we return the same result we did for the other thread, i.e. the | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
767 // successfully loaded InstanceKlass |
| 0 | 768 // Should not get here for classloaders that support parallelism |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
769 // with the new cleaner mechanism, even with AllowParallelDefineClass |
| 514 | 770 // Bootstrap goes through here to allow for an extra guarantee check |
| 0 | 771 if (UnsyncloadClass || (class_loader.is_null())) { |
| 772 if (k.is_null() && HAS_PENDING_EXCEPTION | |
| 1142 | 773 && PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { |
| 0 | 774 MutexLocker mu(SystemDictionary_lock, THREAD); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
775 Klass* check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 776 if (check != NULL) { |
| 777 // Klass is already loaded, so just use it | |
| 778 k = instanceKlassHandle(THREAD, check); | |
| 779 CLEAR_PENDING_EXCEPTION; | |
| 780 guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?"); | |
| 781 } | |
| 782 } | |
| 783 } | |
| 784 | |
| 785 // clean up placeholder entries for success or error | |
| 786 // This cleans up LOAD_INSTANCE entries | |
| 787 // It also cleans up LOAD_SUPER entries on errors from | |
| 788 // calling load_instance_class | |
| 789 { | |
| 790 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
791 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
| 0 | 792 if (probe != NULL) { |
| 793 probe->remove_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
794 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
| 0 | 795 SystemDictionary_lock->notify_all(); |
| 796 } | |
| 797 } | |
| 798 | |
| 799 // If everything was OK (no exceptions, no null return value), and | |
| 800 // class_loader is NOT the defining loader, do a little more bookkeeping. | |
| 801 if (!HAS_PENDING_EXCEPTION && !k.is_null() && | |
| 802 k->class_loader() != class_loader()) { | |
| 803 | |
| 804 check_constraints(d_index, d_hash, k, class_loader, false, THREAD); | |
| 805 | |
| 806 // Need to check for a PENDING_EXCEPTION again; check_constraints | |
| 807 // can throw and doesn't use the CHECK macro. | |
| 808 if (!HAS_PENDING_EXCEPTION) { | |
| 809 { // Grabbing the Compile_lock prevents systemDictionary updates | |
| 810 // during compilations. | |
| 811 MutexLocker mu(Compile_lock, THREAD); | |
| 812 update_dictionary(d_index, d_hash, p_index, p_hash, | |
| 813 k, class_loader, THREAD); | |
| 814 } | |
| 815 if (JvmtiExport::should_post_class_load()) { | |
| 816 Thread *thread = THREAD; | |
| 817 assert(thread->is_Java_thread(), "thread->is_Java_thread()"); | |
| 818 JvmtiExport::post_class_load((JavaThread *) thread, k()); | |
| 819 } | |
| 820 } | |
| 821 } | |
| 822 if (HAS_PENDING_EXCEPTION || k.is_null()) { | |
| 823 // On error, clean up placeholders | |
| 824 { | |
| 825 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
826 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
| 0 | 827 SystemDictionary_lock->notify_all(); |
| 828 } | |
| 829 return NULL; | |
| 830 } | |
| 831 } | |
| 832 } | |
| 833 | |
| 834 #ifdef ASSERT | |
| 835 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
836 ClassLoaderData* loader_data = k->class_loader_data(); |
| 0 | 837 MutexLocker mu(SystemDictionary_lock, THREAD); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
838 Klass* kk = find_class(name, loader_data); |
| 0 | 839 assert(kk == k(), "should be present in dictionary"); |
| 840 } | |
| 841 #endif | |
| 842 | |
| 843 // return if the protection domain in NULL | |
| 844 if (protection_domain() == NULL) return k(); | |
| 845 | |
| 846 // Check the protection domain has the right access | |
| 847 { | |
| 848 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 849 // Note that we have an entry, and entries can be deleted only during GC, | |
| 850 // so we cannot allow GC to occur while we're holding this entry. | |
| 851 // We're using a No_Safepoint_Verifier to catch any place where we | |
| 852 // might potentially do a GC at all. | |
| 853 // SystemDictionary::do_unloading() asserts that classes are only | |
| 854 // unloaded at a safepoint. | |
| 855 No_Safepoint_Verifier nosafepoint; | |
| 856 if (dictionary()->is_valid_protection_domain(d_index, d_hash, name, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
857 loader_data, |
| 0 | 858 protection_domain)) { |
| 859 return k(); | |
| 860 } | |
| 861 } | |
| 862 | |
| 863 // Verify protection domain. If it fails an exception is thrown | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
864 validate_protection_domain(k, class_loader, protection_domain, CHECK_NULL); |
| 0 | 865 |
| 866 return k(); | |
| 867 } | |
| 868 | |
| 869 | |
| 870 // This routine does not lock the system dictionary. | |
| 871 // | |
| 872 // Since readers don't hold a lock, we must make sure that system | |
| 873 // dictionary entries are only removed at a safepoint (when only one | |
| 874 // thread is running), and are added to in a safe way (all links must | |
| 875 // be updated in an MT-safe manner). | |
| 876 // | |
| 877 // Callers should be aware that an entry could be added just after | |
| 878 // _dictionary->bucket(index) is read here, so the caller will not see | |
| 879 // the new entry. | |
| 880 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
881 Klass* SystemDictionary::find(Symbol* class_name, |
| 0 | 882 Handle class_loader, |
| 883 Handle protection_domain, | |
| 884 TRAPS) { | |
| 885 | |
|
556
48bb4a49b7ac
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
431
diff
changeset
|
886 // UseNewReflection |
|
48bb4a49b7ac
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
431
diff
changeset
|
887 // The result of this call should be consistent with the result |
|
48bb4a49b7ac
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
431
diff
changeset
|
888 // of the call to resolve_instance_class_or_null(). |
|
48bb4a49b7ac
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
431
diff
changeset
|
889 // See evaluation 6790209 and 4474172 for more details. |
|
48bb4a49b7ac
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
431
diff
changeset
|
890 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
891 ClassLoaderData* loader_data = register_loader(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
892 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
893 unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data); |
| 0 | 894 int d_index = dictionary()->hash_to_index(d_hash); |
| 895 | |
| 896 { | |
| 897 // Note that we have an entry, and entries can be deleted only during GC, | |
| 898 // so we cannot allow GC to occur while we're holding this entry. | |
| 899 // We're using a No_Safepoint_Verifier to catch any place where we | |
| 900 // might potentially do a GC at all. | |
| 901 // SystemDictionary::do_unloading() asserts that classes are only | |
| 902 // unloaded at a safepoint. | |
| 903 No_Safepoint_Verifier nosafepoint; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
904 return dictionary()->find(d_index, d_hash, class_name, loader_data, |
| 0 | 905 protection_domain, THREAD); |
| 906 } | |
| 907 } | |
| 908 | |
| 909 | |
| 910 // Look for a loaded instance or array klass by name. Do not do any loading. | |
| 911 // return NULL in case of error. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
912 Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name, |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
913 Handle class_loader, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
914 Handle protection_domain, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
915 TRAPS) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
916 Klass* k = NULL; |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
917 assert(class_name != NULL, "class name must be non NULL"); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
918 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
919 if (FieldType::is_array(class_name)) { |
| 0 | 920 // The name refers to an array. Parse the name. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
921 // dimension and object_key in FieldArrayInfo are assigned as a |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
922 // side-effect of this call |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
923 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
924 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
| 0 | 925 if (t != T_OBJECT) { |
| 926 k = Universe::typeArrayKlassObj(t); | |
| 927 } else { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
928 k = SystemDictionary::find(fd.object_key(), class_loader, protection_domain, THREAD); |
| 0 | 929 } |
| 930 if (k != NULL) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
931 k = Klass::cast(k)->array_klass_or_null(fd.dimension()); |
| 0 | 932 } |
| 933 } else { | |
| 934 k = find(class_name, class_loader, protection_domain, THREAD); | |
| 935 } | |
| 936 return k; | |
| 937 } | |
| 938 | |
| 939 // Note: this method is much like resolve_from_stream, but | |
| 940 // updates no supplemental data structures. | |
| 941 // TODO consolidate the two methods with a helper routine? | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
942 Klass* SystemDictionary::parse_stream(Symbol* class_name, |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
943 Handle class_loader, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
944 Handle protection_domain, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
945 ClassFileStream* st, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
946 KlassHandle host_klass, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
947 GrowableArray<Handle>* cp_patches, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
948 TRAPS) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
949 TempNewSymbol parsed_name = NULL; |
| 0 | 950 |
| 951 // Parse the stream. Note that we do this even though this klass might | |
| 952 // already be present in the SystemDictionary, otherwise we would not | |
| 953 // throw potential ClassFormatErrors. | |
| 954 // | |
| 955 // Note: "name" is updated. | |
| 956 // Further note: a placeholder will be added for this class when | |
| 957 // super classes are loaded (resolve_super_or_fail). We expect this | |
| 958 // to be called for all classes but java.lang.Object; and we preload | |
| 959 // java.lang.Object through resolve_or_fail, not this path. | |
| 960 | |
| 961 instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name, | |
| 962 class_loader, | |
| 963 protection_domain, | |
| 710 | 964 host_klass, |
| 965 cp_patches, | |
| 0 | 966 parsed_name, |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
875
diff
changeset
|
967 true, |
| 0 | 968 THREAD); |
| 969 | |
| 970 // We don't redefine the class, so we just need to clean up whether there | |
| 971 // was an error or not (don't want to modify any system dictionary | |
| 972 // data structures). | |
| 973 // Parsed name could be null if we threw an error before we got far | |
| 974 // enough along to parse it -- in that case, there is nothing to clean up. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
975 if (parsed_name != NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
976 ClassLoaderData* loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
977 |
| 0 | 978 unsigned int p_hash = placeholders()->compute_hash(parsed_name, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
979 loader_data); |
| 0 | 980 int p_index = placeholders()->hash_to_index(p_hash); |
| 981 { | |
| 982 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
983 placeholders()->find_and_remove(p_index, p_hash, parsed_name, loader_data, THREAD); |
| 0 | 984 SystemDictionary_lock->notify_all(); |
| 985 } | |
| 986 } | |
| 987 | |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
988 if (host_klass.not_null() && k.not_null()) { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
989 assert(EnableInvokeDynamic, ""); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
990 // If it's anonymous, initialize it now, since nobody else will. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
991 k->class_loader_data()->record_dependency(host_klass(), CHECK_NULL); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
992 k->set_host_klass(host_klass()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
993 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
994 { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
995 MutexLocker mu_r(Compile_lock, THREAD); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
996 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
997 // Add to class hierarchy, initialize vtables, and do possible |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
998 // deoptimizations. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
999 add_to_hierarchy(k, CHECK_NULL); // No exception, but can block |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1000 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1001 // But, do not add to system dictionary. |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1002 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1003 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1004 // Rewrite and patch constant pool here. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1005 k->link_class(THREAD); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1006 if (cp_patches != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1007 k->constants()->patch_resolved_references(cp_patches); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1008 } |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1009 k->eager_initialize(THREAD); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1010 |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1011 // notify jvmti |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1012 if (JvmtiExport::should_post_class_load()) { |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1013 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1014 JvmtiExport::post_class_load((JavaThread *) THREAD, k()); |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1015 } |
|
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1016 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1017 assert(host_klass.not_null() || cp_patches == NULL, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1018 "cp_patches only found with host_klass"); |
|
431
a45484ea312d
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
196
diff
changeset
|
1019 |
| 0 | 1020 return k(); |
| 1021 } | |
| 1022 | |
| 1023 // Add a klass to the system from a stream (called by jni_DefineClass and | |
| 1024 // JVM_DefineClass). | |
| 1025 // Note: class_name can be NULL. In that case we do not know the name of | |
| 1026 // the class until we have parsed the stream. | |
| 1027 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1028 Klass* SystemDictionary::resolve_from_stream(Symbol* class_name, |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
1029 Handle class_loader, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
1030 Handle protection_domain, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
1031 ClassFileStream* st, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
1032 bool verify, |
|
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
1033 TRAPS) { |
| 0 | 1034 |
| 514 | 1035 // Classloaders that support parallelism, e.g. bootstrap classloader, |
| 1036 // or all classloaders with UnsyncloadClass do not acquire lock here | |
| 1037 bool DoObjectLock = true; | |
| 1038 if (is_parallelCapable(class_loader)) { | |
| 1039 DoObjectLock = false; | |
| 1040 } | |
| 1041 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1042 ClassLoaderData* loader_data = register_loader(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1043 |
| 514 | 1044 // Make sure we are synchronized on the class loader before we proceed |
| 0 | 1045 Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
| 1046 check_loader_lock_contention(lockObject, THREAD); | |
| 514 | 1047 ObjectLocker ol(lockObject, THREAD, DoObjectLock); |
| 0 | 1048 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1049 TempNewSymbol parsed_name = NULL; |
| 0 | 1050 |
| 1051 // Parse the stream. Note that we do this even though this klass might | |
| 1052 // already be present in the SystemDictionary, otherwise we would not | |
| 1053 // throw potential ClassFormatErrors. | |
| 1054 // | |
| 1055 // Note: "name" is updated. | |
| 1056 // Further note: a placeholder will be added for this class when | |
| 1057 // super classes are loaded (resolve_super_or_fail). We expect this | |
| 1058 // to be called for all classes but java.lang.Object; and we preload | |
| 1059 // java.lang.Object through resolve_or_fail, not this path. | |
| 1060 | |
| 1061 instanceKlassHandle k = ClassFileParser(st).parseClassFile(class_name, | |
| 1062 class_loader, | |
| 1063 protection_domain, | |
| 1064 parsed_name, | |
|
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
875
diff
changeset
|
1065 verify, |
| 0 | 1066 THREAD); |
| 1067 | |
| 1068 const char* pkg = "java/"; | |
| 1069 if (!HAS_PENDING_EXCEPTION && | |
| 1070 !class_loader.is_null() && | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1071 parsed_name != NULL && |
| 0 | 1072 !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) { |
| 1073 // It is illegal to define classes in the "java." package from | |
| 1074 // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader | |
| 1075 ResourceMark rm(THREAD); | |
| 1076 char* name = parsed_name->as_C_string(); | |
| 1077 char* index = strrchr(name, '/'); | |
| 1078 *index = '\0'; // chop to just the package name | |
| 1079 while ((index = strchr(name, '/')) != NULL) { | |
| 1080 *index = '.'; // replace '/' with '.' in package name | |
| 1081 } | |
| 1082 const char* fmt = "Prohibited package name: %s"; | |
| 1083 size_t len = strlen(fmt) + strlen(name); | |
| 1084 char* message = NEW_RESOURCE_ARRAY(char, len); | |
| 1085 jio_snprintf(message, len, fmt, name); | |
| 1086 Exceptions::_throw_msg(THREAD_AND_LOCATION, | |
| 1087 vmSymbols::java_lang_SecurityException(), message); | |
| 1088 } | |
| 1089 | |
| 1090 if (!HAS_PENDING_EXCEPTION) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1091 assert(parsed_name != NULL, "Sanity"); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1092 assert(class_name == NULL || class_name == parsed_name, "name mismatch"); |
| 0 | 1093 // Verification prevents us from creating names with dots in them, this |
| 1094 // asserts that that's the case. | |
| 1095 assert(is_internal_format(parsed_name), | |
| 1096 "external class name format used internally"); | |
| 1097 | |
| 1098 // Add class just loaded | |
| 514 | 1099 // If a class loader supports parallel classloading handle parallel define requests |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1100 // find_or_define_instance_class may return a different InstanceKlass |
| 514 | 1101 if (is_parallelCapable(class_loader)) { |
| 1102 k = find_or_define_instance_class(class_name, class_loader, k, THREAD); | |
| 1103 } else { | |
| 1104 define_instance_class(k, THREAD); | |
| 1105 } | |
| 0 | 1106 } |
| 1107 | |
| 1108 // If parsing the class file or define_instance_class failed, we | |
| 1109 // need to remove the placeholder added on our behalf. But we | |
| 1110 // must make sure parsed_name is valid first (it won't be if we had | |
| 1111 // a format error before the class was parsed far enough to | |
| 1112 // find the name). | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1113 if (HAS_PENDING_EXCEPTION && parsed_name != NULL) { |
| 0 | 1114 unsigned int p_hash = placeholders()->compute_hash(parsed_name, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1115 loader_data); |
| 0 | 1116 int p_index = placeholders()->hash_to_index(p_hash); |
| 1117 { | |
| 1118 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1119 placeholders()->find_and_remove(p_index, p_hash, parsed_name, loader_data, THREAD); |
| 0 | 1120 SystemDictionary_lock->notify_all(); |
| 1121 } | |
| 1122 return NULL; | |
| 1123 } | |
| 1124 | |
| 1125 // Make sure that we didn't leave a place holder in the | |
| 1126 // SystemDictionary; this is only done on success | |
| 1127 debug_only( { | |
| 1128 if (!HAS_PENDING_EXCEPTION) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1129 assert(parsed_name != NULL, "parsed_name is still null?"); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1130 Symbol* h_name = k->name(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1131 ClassLoaderData *defining_loader_data = k->class_loader_data(); |
| 0 | 1132 |
| 1133 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 1134 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1135 Klass* check = find_class(parsed_name, loader_data); |
| 0 | 1136 assert(check == k(), "should be present in the dictionary"); |
| 1137 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1138 Klass* check2 = find_class(h_name, defining_loader_data); |
| 0 | 1139 assert(check == check2, "name inconsistancy in SystemDictionary"); |
| 1140 } | |
| 1141 } ); | |
| 1142 | |
| 1143 return k(); | |
| 1144 } | |
| 1145 | |
| 1146 | |
| 6197 | 1147 void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length, |
| 0 | 1148 int number_of_entries) { |
| 6197 | 1149 assert(length == _nof_buckets * sizeof(HashtableBucket<mtClass>), |
| 0 | 1150 "bad shared dictionary size."); |
| 1151 _shared_dictionary = new Dictionary(_nof_buckets, t, number_of_entries); | |
| 1152 } | |
| 1153 | |
| 1154 | |
| 1155 // If there is a shared dictionary, then find the entry for the | |
| 1156 // given shared system class, if any. | |
| 1157 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1158 Klass* SystemDictionary::find_shared_class(Symbol* class_name) { |
| 0 | 1159 if (shared_dictionary() != NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1160 unsigned int d_hash = shared_dictionary()->compute_hash(class_name, NULL); |
|
4864
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1161 int d_index = shared_dictionary()->hash_to_index(d_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1162 |
| 0 | 1163 return shared_dictionary()->find_shared_class(d_index, d_hash, class_name); |
| 1164 } else { | |
| 1165 return NULL; | |
| 1166 } | |
| 1167 } | |
| 1168 | |
| 1169 | |
| 1170 // Load a class from the shared spaces (found through the shared system | |
| 1171 // dictionary). Force the superclass and all interfaces to be loaded. | |
| 1172 // Update the class definition to include sibling classes and no | |
| 1173 // subclasses (yet). [Classes in the shared space are not part of the | |
| 1174 // object hierarchy until loaded.] | |
| 1175 | |
| 1176 instanceKlassHandle SystemDictionary::load_shared_class( | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1177 Symbol* class_name, Handle class_loader, TRAPS) { |
| 0 | 1178 instanceKlassHandle ik (THREAD, find_shared_class(class_name)); |
| 1179 return load_shared_class(ik, class_loader, THREAD); | |
| 1180 } | |
| 1181 | |
| 1182 // Note well! Changes to this method may affect oop access order | |
| 1183 // in the shared archive. Please take care to not make changes that | |
| 1184 // adversely affect cold start time by changing the oop access order | |
| 1185 // that is specified in dump.cpp MarkAndMoveOrderedReadOnly and | |
| 1186 // MarkAndMoveOrderedReadWrite closures. | |
| 1187 instanceKlassHandle SystemDictionary::load_shared_class( | |
| 1188 instanceKlassHandle ik, Handle class_loader, TRAPS) { | |
| 1189 assert(class_loader.is_null(), "non-null classloader for shared class?"); | |
| 1190 if (ik.not_null()) { | |
| 1191 instanceKlassHandle nh = instanceKlassHandle(); // null Handle | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1192 Symbol* class_name = ik->name(); |
| 0 | 1193 |
| 1194 // Found the class, now load the superclass and interfaces. If they | |
| 1195 // are shared, add them to the main system dictionary and reset | |
| 1196 // their hierarchy references (supers, subs, and interfaces). | |
| 1197 | |
| 1198 if (ik->super() != NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1199 Symbol* cn = ik->super()->name(); |
| 0 | 1200 resolve_super_or_fail(class_name, cn, |
| 1201 class_loader, Handle(), true, CHECK_(nh)); | |
| 1202 } | |
| 1203 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1204 Array<Klass*>* interfaces = ik->local_interfaces(); |
| 0 | 1205 int num_interfaces = interfaces->length(); |
| 1206 for (int index = 0; index < num_interfaces; index++) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1207 Klass* k = interfaces->at(index); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1208 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1209 // Note: can not use InstanceKlass::cast here because |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1210 // interfaces' InstanceKlass's C++ vtbls haven't been |
| 0 | 1211 // reinitialized yet (they will be once the interface classes |
| 1212 // are loaded) | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1213 Symbol* name = k->name(); |
| 0 | 1214 resolve_super_or_fail(class_name, name, class_loader, Handle(), false, CHECK_(nh)); |
| 1215 } | |
| 1216 | |
| 1217 // Adjust methods to recover missing data. They need addresses for | |
| 1218 // interpreter entry points and their default native method address | |
| 1219 // must be reset. | |
| 1220 | |
| 1221 // Updating methods must be done under a lock so multiple | |
| 1222 // threads don't update these in parallel | |
| 1223 // Shared classes are all currently loaded by the bootstrap | |
| 1224 // classloader, so this will never cause a deadlock on | |
| 1225 // a custom class loader lock. | |
| 1226 | |
| 1227 { | |
| 1228 Handle lockObject = compute_loader_lock_object(class_loader, THREAD); | |
| 1229 check_loader_lock_contention(lockObject, THREAD); | |
| 1230 ObjectLocker ol(lockObject, THREAD, true); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1231 ik->restore_unshareable_info(CHECK_(nh)); |
| 0 | 1232 } |
| 1233 | |
| 1234 if (TraceClassLoading) { | |
| 1235 ResourceMark rm; | |
| 1236 tty->print("[Loaded %s", ik->external_name()); | |
| 1237 tty->print(" from shared objects file"); | |
| 1238 tty->print_cr("]"); | |
| 1239 } | |
| 1240 // notify a class loaded from shared object | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1241 ClassLoadingService::notify_class_loaded(InstanceKlass::cast(ik()), |
| 0 | 1242 true /* shared class */); |
| 1243 } | |
| 1244 return ik; | |
| 1245 } | |
| 1246 | |
| 1247 #ifdef KERNEL | |
| 1248 // Some classes on the bootstrap class path haven't been installed on the | |
| 1249 // system yet. Call the DownloadManager method to make them appear in the | |
| 1250 // bootstrap class path and try again to load the named class. | |
| 1251 // Note that with delegation class loaders all classes in another loader will | |
| 1252 // first try to call this so it'd better be fast!! | |
| 1253 static instanceKlassHandle download_and_retry_class_load( | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1254 Symbol* class_name, |
| 0 | 1255 TRAPS) { |
| 1256 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1257 Klass* dlm = SystemDictionary::DownloadManager_klass(); |
| 0 | 1258 instanceKlassHandle nk; |
| 1259 | |
| 1260 // If download manager class isn't loaded just return. | |
| 1261 if (dlm == NULL) return nk; | |
| 1262 | |
| 1263 { HandleMark hm(THREAD); | |
| 1264 ResourceMark rm(THREAD); | |
| 1265 Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nk)); | |
| 1266 Handle class_string = java_lang_String::externalize_classname(s, CHECK_(nk)); | |
| 1267 | |
| 1268 // return value | |
| 1269 JavaValue result(T_OBJECT); | |
| 1270 | |
| 1271 // Call the DownloadManager. We assume that it has a lock because | |
| 1272 // multiple classes could be not found and downloaded at the same time. | |
| 1273 // class sun.misc.DownloadManager; | |
| 1274 // public static String getBootClassPathEntryForClass(String className); | |
| 1275 JavaCalls::call_static(&result, | |
| 1276 KlassHandle(THREAD, dlm), | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1277 vmSymbols::getBootClassPathEntryForClass_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1278 vmSymbols::string_string_signature(), |
| 0 | 1279 class_string, |
| 1280 CHECK_(nk)); | |
| 1281 | |
| 1282 // Get result.string and add to bootclasspath | |
| 1283 assert(result.get_type() == T_OBJECT, "just checking"); | |
| 1284 oop obj = (oop) result.get_jobject(); | |
| 1285 if (obj == NULL) { return nk; } | |
| 1286 | |
|
22
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
1287 Handle h_obj(THREAD, obj); |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
1288 char* new_class_name = java_lang_String::as_platform_dependent_str(h_obj, |
|
90f5ddc7297b
6646946: Kernel installation failed on Japanese and Chinese XP SP2 (VM part)
coleenp
parents:
0
diff
changeset
|
1289 CHECK_(nk)); |
| 0 | 1290 |
| 1291 // lock the loader | |
| 1292 // we use this lock because JVMTI does. | |
| 1293 Handle loader_lock(THREAD, SystemDictionary::system_loader_lock()); | |
| 1294 | |
| 1295 ObjectLocker ol(loader_lock, THREAD); | |
| 1296 // add the file to the bootclasspath | |
| 1297 ClassLoader::update_class_path_entry_list(new_class_name, true); | |
| 1298 } // end HandleMark | |
| 1299 | |
| 1300 if (TraceClassLoading) { | |
| 1301 ClassLoader::print_bootclasspath(); | |
| 1302 } | |
| 1303 return ClassLoader::load_classfile(class_name, CHECK_(nk)); | |
| 1304 } | |
| 1305 #endif // KERNEL | |
| 1306 | |
| 1307 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1308 instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) { |
| 0 | 1309 instanceKlassHandle nh = instanceKlassHandle(); // null Handle |
| 1310 if (class_loader.is_null()) { | |
|
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1311 |
| 0 | 1312 // Search the shared system dictionary for classes preloaded into the |
| 1313 // shared spaces. | |
| 1314 instanceKlassHandle k; | |
|
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1315 { |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1316 PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time()); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1317 k = load_shared_class(class_name, class_loader, THREAD); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1318 } |
| 0 | 1319 |
| 1320 if (k.is_null()) { | |
| 1321 // Use VM class loader | |
|
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1322 PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time()); |
| 0 | 1323 k = ClassLoader::load_classfile(class_name, CHECK_(nh)); |
| 1324 } | |
| 1325 | |
| 1326 #ifdef KERNEL | |
| 1327 // If the VM class loader has failed to load the class, call the | |
| 1328 // DownloadManager class to make it magically appear on the classpath | |
| 1329 // and try again. This is only configured with the Kernel VM. | |
| 1330 if (k.is_null()) { | |
| 1331 k = download_and_retry_class_load(class_name, CHECK_(nh)); | |
| 1332 } | |
| 1333 #endif // KERNEL | |
| 1334 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1335 // find_or_define_instance_class may return a different InstanceKlass |
| 0 | 1336 if (!k.is_null()) { |
| 1337 k = find_or_define_instance_class(class_name, class_loader, k, CHECK_(nh)); | |
| 1338 } | |
| 1339 return k; | |
| 1340 } else { | |
| 1341 // Use user specified class loader to load class. Call loadClass operation on class_loader. | |
| 1342 ResourceMark rm(THREAD); | |
| 1343 | |
|
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1344 assert(THREAD->is_Java_thread(), "must be a JavaThread"); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1345 JavaThread* jt = (JavaThread*) THREAD; |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1346 |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1347 PerfClassTraceTime vmtimer(ClassLoader::perf_app_classload_time(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1348 ClassLoader::perf_app_classload_selftime(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1349 ClassLoader::perf_app_classload_count(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1350 jt->get_thread_stat()->perf_recursion_counts_addr(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1351 jt->get_thread_stat()->perf_timers_addr(), |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1352 PerfClassTraceTime::CLASS_LOAD); |
|
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
726
diff
changeset
|
1353 |
| 0 | 1354 Handle s = java_lang_String::create_from_symbol(class_name, CHECK_(nh)); |
| 1355 // Translate to external class name format, i.e., convert '/' chars to '.' | |
| 1356 Handle string = java_lang_String::externalize_classname(s, CHECK_(nh)); | |
| 1357 | |
| 1358 JavaValue result(T_OBJECT); | |
| 1359 | |
| 1142 | 1360 KlassHandle spec_klass (THREAD, SystemDictionary::ClassLoader_klass()); |
| 0 | 1361 |
| 514 | 1362 // Call public unsynchronized loadClass(String) directly for all class loaders |
| 1363 // for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will | |
| 1364 // acquire a class-name based lock rather than the class loader object lock. | |
| 1365 // JDK < 7 already acquire the class loader lock in loadClass(String, boolean), | |
| 1366 // so the call to loadClassInternal() was not required. | |
| 1367 // | |
| 1368 // UnsyncloadClass flag means both call loadClass(String) and do | |
| 1369 // not acquire the class loader lock even for class loaders that are | |
| 1370 // not parallelCapable. This was a risky transitional | |
| 1371 // flag for diagnostic purposes only. It is risky to call | |
| 0 | 1372 // custom class loaders without synchronization. |
| 1373 // WARNING If a custom class loader does NOT synchronizer findClass, or callers of | |
| 514 | 1374 // findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field. |
| 0 | 1375 // Do NOT assume this will be supported in future releases. |
| 514 | 1376 // |
| 1377 // Added MustCallLoadClassInternal in case we discover in the field | |
| 1378 // a customer that counts on this call | |
| 1379 if (MustCallLoadClassInternal && has_loadClassInternal()) { | |
| 0 | 1380 JavaCalls::call_special(&result, |
| 1381 class_loader, | |
| 1382 spec_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1383 vmSymbols::loadClassInternal_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1384 vmSymbols::string_class_signature(), |
| 0 | 1385 string, |
| 1386 CHECK_(nh)); | |
| 1387 } else { | |
| 1388 JavaCalls::call_virtual(&result, | |
| 1389 class_loader, | |
| 1390 spec_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1391 vmSymbols::loadClass_name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1392 vmSymbols::string_class_signature(), |
| 0 | 1393 string, |
| 1394 CHECK_(nh)); | |
| 1395 } | |
| 1396 | |
| 1397 assert(result.get_type() == T_OBJECT, "just checking"); | |
| 1398 oop obj = (oop) result.get_jobject(); | |
| 1399 | |
| 1400 // Primitive classes return null since forName() can not be | |
| 1401 // used to obtain any of the Class objects representing primitives or void | |
| 1402 if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) { | |
| 1403 instanceKlassHandle k = | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1404 instanceKlassHandle(THREAD, java_lang_Class::as_Klass(obj)); |
| 0 | 1405 // For user defined Java class loaders, check that the name returned is |
| 1406 // the same as that requested. This check is done for the bootstrap | |
| 1407 // loader when parsing the class file. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1408 if (class_name == k->name()) { |
| 0 | 1409 return k; |
| 1410 } | |
| 1411 } | |
| 1412 // Class is not found or has the wrong name, return NULL | |
| 1413 return nh; | |
| 1414 } | |
| 1415 } | |
| 1416 | |
| 1417 void SystemDictionary::define_instance_class(instanceKlassHandle k, TRAPS) { | |
| 1418 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1419 ClassLoaderData* loader_data = k->class_loader_data(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1420 Handle class_loader_h(THREAD, loader_data->class_loader()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1421 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1422 for (uintx it = 0; it < GCExpandToAllocateDelayMillis; it++){} |
| 0 | 1423 |
| 514 | 1424 // for bootstrap and other parallel classloaders don't acquire lock, |
| 1425 // use placeholder token | |
| 1426 // If a parallelCapable class loader calls define_instance_class instead of | |
| 1427 // find_or_define_instance_class to get here, we have a timing | |
| 1428 // hole with systemDictionary updates and check_constraints | |
| 1429 if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) { | |
| 0 | 1430 assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, |
| 1431 compute_loader_lock_object(class_loader_h, THREAD)), | |
| 1432 "define called without lock"); | |
| 1433 } | |
| 1434 | |
| 1435 // Check class-loading constraints. Throw exception if violation is detected. | |
| 1436 // Grabs and releases SystemDictionary_lock | |
| 1437 // The check_constraints/find_class call and update_dictionary sequence | |
| 1438 // must be "atomic" for a specific class/classloader pair so we never | |
| 1439 // define two different instanceKlasses for that class/classloader pair. | |
| 1440 // Existing classloaders will call define_instance_class with the | |
| 1441 // classloader lock held | |
| 1442 // Parallel classloaders will call find_or_define_instance_class | |
| 1443 // which will require a token to perform the define class | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1444 Symbol* name_h = k->name(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1445 unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data); |
| 0 | 1446 int d_index = dictionary()->hash_to_index(d_hash); |
| 1447 check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK); | |
| 1448 | |
|
6751
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1449 // Register class just loaded with class loader (placed in Vector) |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1450 // Note we do this before updating the dictionary, as this can |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1451 // fail with an OutOfMemoryError (if it does, we will *not* put this |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1452 // class in the dictionary and will not update the class hierarchy). |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1453 // JVMTI FollowReferences needs to find the classes this way. |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1454 if (k->class_loader() != NULL) { |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1455 methodHandle m(THREAD, Universe::loader_addClass_method()); |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1456 JavaValue result(T_VOID); |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1457 JavaCallArguments args(class_loader_h); |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1458 args.push_oop(Handle(THREAD, k->java_mirror())); |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1459 JavaCalls::call(&result, m, &args, CHECK); |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1460 } |
|
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6735
diff
changeset
|
1461 |
| 0 | 1462 // Add the new class. We need recompile lock during update of CHA. |
| 1463 { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1464 unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data); |
| 0 | 1465 int p_index = placeholders()->hash_to_index(p_hash); |
| 1466 | |
| 1467 MutexLocker mu_r(Compile_lock, THREAD); | |
| 1468 | |
| 1469 // Add to class hierarchy, initialize vtables, and do possible | |
| 1470 // deoptimizations. | |
| 1471 add_to_hierarchy(k, CHECK); // No exception, but can block | |
| 1472 | |
| 1473 // Add to systemDictionary - so other classes can see it. | |
| 1474 // Grabs and releases SystemDictionary_lock | |
| 1475 update_dictionary(d_index, d_hash, p_index, p_hash, | |
| 1476 k, class_loader_h, THREAD); | |
| 1477 } | |
| 1478 k->eager_initialize(THREAD); | |
| 1479 | |
| 1480 // notify jvmti | |
| 1481 if (JvmtiExport::should_post_class_load()) { | |
| 1482 assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); | |
| 1483 JvmtiExport::post_class_load((JavaThread *) THREAD, k()); | |
| 1484 | |
| 1485 } | |
| 1486 } | |
| 1487 | |
| 1488 // Support parallel classloading | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1489 // All parallel class loaders, including bootstrap classloader |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1490 // lock a placeholder entry for this class/class_loader pair |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1491 // to allow parallel defines of different classes for this class loader |
| 514 | 1492 // With AllowParallelDefine flag==true, in case they do not synchronize around |
| 1493 // FindLoadedClass/DefineClass, calls, we check for parallel | |
| 0 | 1494 // loading for them, wait if a defineClass is in progress |
| 1495 // and return the initial requestor's results | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1496 // This flag does not apply to the bootstrap classloader. |
| 514 | 1497 // With AllowParallelDefine flag==false, call through to define_instance_class |
| 1498 // which will throw LinkageError: duplicate class definition. | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1499 // False is the requested default. |
| 0 | 1500 // For better performance, the class loaders should synchronize |
| 514 | 1501 // findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they |
| 0 | 1502 // potentially waste time reading and parsing the bytestream. |
| 1503 // Note: VM callers should ensure consistency of k/class_name,class_loader | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1504 instanceKlassHandle SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, instanceKlassHandle k, TRAPS) { |
| 0 | 1505 |
| 1506 instanceKlassHandle nh = instanceKlassHandle(); // null Handle | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1507 Symbol* name_h = k->name(); // passed in class_name may be null |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1508 ClassLoaderData* loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1509 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1510 unsigned int d_hash = dictionary()->compute_hash(name_h, loader_data); |
| 0 | 1511 int d_index = dictionary()->hash_to_index(d_hash); |
| 1512 | |
| 1513 // Hold SD lock around find_class and placeholder creation for DEFINE_CLASS | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1514 unsigned int p_hash = placeholders()->compute_hash(name_h, loader_data); |
| 0 | 1515 int p_index = placeholders()->hash_to_index(p_hash); |
| 1516 PlaceholderEntry* probe; | |
| 1517 | |
| 1518 { | |
| 1519 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 1520 // First check if class already defined | |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1521 if (UnsyncloadClass || (is_parallelDefine(class_loader))) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1522 Klass* check = find_class(d_index, d_hash, name_h, loader_data); |
|
1075
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1523 if (check != NULL) { |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1524 return(instanceKlassHandle(THREAD, check)); |
|
a75edfd400ea
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
1039
diff
changeset
|
1525 } |
| 0 | 1526 } |
| 1527 | |
| 1528 // Acquire define token for this class/classloader | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1529 probe = placeholders()->find_and_add(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, NULL, THREAD); |
| 514 | 1530 // Wait if another thread defining in parallel |
| 1531 // All threads wait - even those that will throw duplicate class: otherwise | |
| 1532 // caller is surprised by LinkageError: duplicate, but findLoadedClass fails | |
| 1533 // if other thread has not finished updating dictionary | |
| 1534 while (probe->definer() != NULL) { | |
| 1535 SystemDictionary_lock->wait(); | |
| 1536 } | |
| 1537 // Only special cases allow parallel defines and can use other thread's results | |
| 1538 // Other cases fall through, and may run into duplicate defines | |
| 1539 // caught by finding an entry in the SystemDictionary | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1540 if ((UnsyncloadClass || is_parallelDefine(class_loader)) && (probe->InstanceKlass() != NULL)) { |
| 0 | 1541 probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1542 placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, THREAD); |
| 514 | 1543 SystemDictionary_lock->notify_all(); |
| 0 | 1544 #ifdef ASSERT |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1545 Klass* check = find_class(d_index, d_hash, name_h, loader_data); |
| 514 | 1546 assert(check != NULL, "definer missed recording success"); |
| 0 | 1547 #endif |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1548 return(instanceKlassHandle(THREAD, probe->InstanceKlass())); |
| 0 | 1549 } else { |
| 514 | 1550 // This thread will define the class (even if earlier thread tried and had an error) |
| 1551 probe->set_definer(THREAD); | |
| 0 | 1552 } |
| 1553 } | |
| 1554 | |
| 1555 define_instance_class(k, THREAD); | |
| 1556 | |
| 1557 Handle linkage_exception = Handle(); // null handle | |
| 1558 | |
| 1559 // definer must notify any waiting threads | |
| 1560 { | |
| 1561 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1562 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, loader_data); |
| 0 | 1563 assert(probe != NULL, "DEFINE_CLASS placeholder lost?"); |
| 1564 if (probe != NULL) { | |
| 1565 if (HAS_PENDING_EXCEPTION) { | |
| 1566 linkage_exception = Handle(THREAD,PENDING_EXCEPTION); | |
| 1567 CLEAR_PENDING_EXCEPTION; | |
| 1568 } else { | |
| 1569 probe->set_instanceKlass(k()); | |
| 1570 } | |
| 1571 probe->set_definer(NULL); | |
| 1572 probe->remove_seen_thread(THREAD, PlaceholderTable::DEFINE_CLASS); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1573 placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, THREAD); |
| 0 | 1574 SystemDictionary_lock->notify_all(); |
| 1575 } | |
| 1576 } | |
| 1577 | |
| 1578 // Can't throw exception while holding lock due to rank ordering | |
| 1579 if (linkage_exception() != NULL) { | |
| 1580 THROW_OOP_(linkage_exception(), nh); // throws exception and returns | |
| 1581 } | |
| 1582 | |
| 1583 return k; | |
| 1584 } | |
| 1585 Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) { | |
| 1586 // If class_loader is NULL we synchronize on _system_loader_lock_obj | |
| 1587 if (class_loader.is_null()) { | |
| 1588 return Handle(THREAD, _system_loader_lock_obj); | |
| 1589 } else { | |
| 1590 return class_loader; | |
| 1591 } | |
| 1592 } | |
| 1593 | |
| 1594 // This method is added to check how often we have to wait to grab loader | |
| 1595 // lock. The results are being recorded in the performance counters defined in | |
| 1596 // ClassLoader::_sync_systemLoaderLockContentionRate and | |
| 1597 // ClassLoader::_sync_nonSystemLoaderLockConteionRate. | |
| 1598 void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) { | |
| 1599 if (!UsePerfData) { | |
| 1600 return; | |
| 1601 } | |
| 1602 | |
| 1603 assert(!loader_lock.is_null(), "NULL lock object"); | |
| 1604 | |
| 1605 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock) | |
| 1606 == ObjectSynchronizer::owner_other) { | |
| 1607 // contention will likely happen, so increment the corresponding | |
| 1608 // contention counter. | |
| 1609 if (loader_lock() == _system_loader_lock_obj) { | |
| 1610 ClassLoader::sync_systemLoaderLockContentionRate()->inc(); | |
| 1611 } else { | |
| 1612 ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc(); | |
| 1613 } | |
| 1614 } | |
| 1615 } | |
| 1616 | |
| 1617 // ---------------------------------------------------------------------------- | |
| 1618 // Lookup | |
| 1619 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1620 Klass* SystemDictionary::find_class(int index, unsigned int hash, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1621 Symbol* class_name, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1622 ClassLoaderData* loader_data) { |
| 0 | 1623 assert_locked_or_safepoint(SystemDictionary_lock); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1624 assert (index == dictionary()->index_for(class_name, loader_data), |
| 0 | 1625 "incorrect index?"); |
| 1626 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1627 Klass* k = dictionary()->find_class(index, hash, class_name, loader_data); |
| 0 | 1628 return k; |
| 1629 } | |
| 1630 | |
| 1631 | |
| 1632 // Basic find on classes in the midst of being loaded | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1633 Symbol* SystemDictionary::find_placeholder(Symbol* class_name, |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1634 ClassLoaderData* loader_data) { |
| 0 | 1635 assert_locked_or_safepoint(SystemDictionary_lock); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1636 unsigned int p_hash = placeholders()->compute_hash(class_name, loader_data); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1637 int p_index = placeholders()->hash_to_index(p_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1638 return placeholders()->find_entry(p_index, p_hash, class_name, loader_data); |
| 0 | 1639 } |
| 1640 | |
| 1641 | |
| 1642 // Used for assertions and verification only | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1643 Klass* SystemDictionary::find_class(Symbol* class_name, ClassLoaderData* loader_data) { |
| 0 | 1644 #ifndef ASSERT |
| 1645 guarantee(VerifyBeforeGC || | |
| 1646 VerifyDuringGC || | |
| 1647 VerifyBeforeExit || | |
| 1648 VerifyAfterGC, "too expensive"); | |
| 1649 #endif | |
| 1650 assert_locked_or_safepoint(SystemDictionary_lock); | |
| 1651 | |
| 1652 // First look in the loaded class array | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1653 unsigned int d_hash = dictionary()->compute_hash(class_name, loader_data); |
| 0 | 1654 int d_index = dictionary()->hash_to_index(d_hash); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1655 return find_class(d_index, d_hash, class_name, loader_data); |
| 0 | 1656 } |
| 1657 | |
| 1658 | |
| 1659 // Get the next class in the diictionary. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1660 Klass* SystemDictionary::try_get_next_class() { |
| 0 | 1661 return dictionary()->try_get_next_class(); |
| 1662 } | |
| 1663 | |
| 1664 | |
| 1665 // ---------------------------------------------------------------------------- | |
| 1666 // Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock | |
| 1667 // is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in | |
| 1668 // before a new class is used. | |
| 1669 | |
| 1670 void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) { | |
| 1671 assert(k.not_null(), "just checking"); | |
|
2244
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
1672 assert_locked_or_safepoint(Compile_lock); |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
1673 |
| 0 | 1674 // Link into hierachy. Make sure the vtables are initialized before linking into |
| 1675 k->append_to_sibling_list(); // add to superklass/sibling list | |
| 1676 k->process_interfaces(THREAD); // handle all "implements" declarations | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1677 k->set_init_state(InstanceKlass::loaded); |
| 0 | 1678 // Now flush all code that depended on old class hierarchy. |
| 1679 // Note: must be done *after* linking k into the hierarchy (was bug 12/9/97) | |
| 1680 // Also, first reinitialize vtable because it may have gotten out of synch | |
| 1681 // while the new class wasn't connected to the class hierarchy. | |
| 1682 Universe::flush_dependents_on(k); | |
| 1683 } | |
| 1684 | |
| 1685 | |
| 1686 // ---------------------------------------------------------------------------- | |
| 1687 // GC support | |
| 1688 | |
| 1689 // Following roots during mark-sweep is separated in two phases. | |
| 1690 // | |
| 1691 // The first phase follows preloaded classes and all other system | |
| 1692 // classes, since these will never get unloaded anyway. | |
| 1693 // | |
| 1694 // The second phase removes (unloads) unreachable classes from the | |
| 1695 // system dictionary and follows the remaining classes' contents. | |
| 1696 | |
| 1697 void SystemDictionary::always_strong_oops_do(OopClosure* blk) { | |
| 1698 blk->do_oop(&_java_system_loader); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1699 blk->do_oop(&_system_loader_lock_obj); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1700 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1701 dictionary()->always_strong_oops_do(blk); |
|
6864
dd2b66d09ccd
8000659: NPG: ClassCastExceptions are unexpectedly thrown when testing nashorn
stefank
parents:
6822
diff
changeset
|
1702 |
|
dd2b66d09ccd
8000659: NPG: ClassCastExceptions are unexpectedly thrown when testing nashorn
stefank
parents:
6822
diff
changeset
|
1703 // Visit extra methods |
|
dd2b66d09ccd
8000659: NPG: ClassCastExceptions are unexpectedly thrown when testing nashorn
stefank
parents:
6822
diff
changeset
|
1704 invoke_method_table()->oops_do(blk); |
| 0 | 1705 } |
| 1706 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1707 void SystemDictionary::always_strong_classes_do(KlassClosure* closure) { |
| 0 | 1708 // Follow all system classes and temporary placeholders in dictionary |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1709 dictionary()->always_strong_classes_do(closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1710 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1711 // Placeholders. These represent classes we're actively loading. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1712 placeholders()->classes_do(closure); |
| 0 | 1713 } |
| 1714 | |
|
4864
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1715 // Calculate a "good" systemdictionary size based |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1716 // on predicted or current loaded classes count |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1717 int SystemDictionary::calculate_systemdictionary_size(int classcount) { |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1718 int newsize = _old_default_sdsize; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1719 if ((classcount > 0) && !DumpSharedSpaces) { |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1720 int desiredsize = classcount/_average_depth_goal; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1721 for (newsize = _primelist[_sdgeneration]; _sdgeneration < _prime_array_size -1; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1722 newsize = _primelist[++_sdgeneration]) { |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1723 if (desiredsize <= newsize) { |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1724 break; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1725 } |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1726 } |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1727 } |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1728 return newsize; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1729 } |
| 0 | 1730 bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1731 // First, mark for unload all ClassLoaderData referencing a dead class loader. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1732 bool has_dead_loaders = ClassLoaderDataGraph::do_unloading(is_alive); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1733 bool unloading_occurred = false; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1734 if (has_dead_loaders) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1735 unloading_occurred = dictionary()->do_unloading(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1736 constraints()->purge_loader_constraints(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1737 resolution_errors()->purge_resolution_errors(); |
| 0 | 1738 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1739 return unloading_occurred; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1740 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1741 |
| 0 | 1742 void SystemDictionary::oops_do(OopClosure* f) { |
| 1743 f->do_oop(&_java_system_loader); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1744 f->do_oop(&_system_loader_lock_obj); |
| 0 | 1745 |
| 1746 // Adjust dictionary | |
| 1747 dictionary()->oops_do(f); | |
| 1748 | |
| 710 | 1749 // Visit extra methods |
| 1903 | 1750 invoke_method_table()->oops_do(f); |
| 0 | 1751 } |
| 1752 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1753 // Extended Class redefinition support. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1754 // If one of these classes is replaced, we need to replace it in these places. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1755 // KlassClosure::do_klass should take the address of a class but we can |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1756 // change that later. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1757 void SystemDictionary::preloaded_classes_do(KlassClosure* f) { |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1758 for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1759 f->do_klass(_well_known_klasses[k]); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1760 } |
| 0 | 1761 |
| 1762 { | |
| 1763 for (int i = 0; i < T_VOID+1; i++) { | |
| 1764 if (_box_klasses[i] != NULL) { | |
| 1765 assert(i >= T_BOOLEAN, "checking"); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1766 f->do_klass(_box_klasses[i]); |
| 0 | 1767 } |
| 1768 } | |
| 1769 } | |
| 1770 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1771 FilteredFieldsMap::classes_do(f); |
| 0 | 1772 } |
| 1773 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1774 void SystemDictionary::lazily_loaded_classes_do(KlassClosure* f) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1775 f->do_klass(_abstract_ownable_synchronizer_klass); |
| 0 | 1776 } |
| 1777 | |
| 1778 // Just the classes from defining class loaders | |
| 1779 // Don't iterate over placeholders | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1780 void SystemDictionary::classes_do(void f(Klass*)) { |
| 0 | 1781 dictionary()->classes_do(f); |
| 1782 } | |
| 1783 | |
| 1784 // Added for initialize_itable_for_klass | |
| 1785 // Just the classes from defining class loaders | |
| 1786 // Don't iterate over placeholders | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1787 void SystemDictionary::classes_do(void f(Klass*, TRAPS), TRAPS) { |
| 0 | 1788 dictionary()->classes_do(f, CHECK); |
| 1789 } | |
| 1790 | |
| 1791 // All classes, and their class loaders | |
| 1792 // Don't iterate over placeholders | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1793 void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*)) { |
| 0 | 1794 dictionary()->classes_do(f); |
| 1795 } | |
| 1796 | |
| 1797 // All classes, and their class loaders | |
| 1798 // (added for helpers that use HandleMarks and ResourceMarks) | |
| 1799 // Don't iterate over placeholders | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1800 void SystemDictionary::classes_do(void f(Klass*, ClassLoaderData*, TRAPS), TRAPS) { |
| 0 | 1801 dictionary()->classes_do(f, CHECK); |
| 1802 } | |
| 1803 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1804 void SystemDictionary::placeholders_do(void f(Symbol*)) { |
| 0 | 1805 placeholders()->entries_do(f); |
| 1806 } | |
| 1807 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1808 void SystemDictionary::methods_do(void f(Method*)) { |
| 0 | 1809 dictionary()->methods_do(f); |
| 1903 | 1810 invoke_method_table()->methods_do(f); |
| 0 | 1811 } |
| 1812 | |
| 1813 // ---------------------------------------------------------------------------- | |
| 1814 // Lazily load klasses | |
| 1815 | |
| 1816 void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) { | |
| 1817 assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); | |
| 1818 | |
| 1819 // if multiple threads calling this function, only one thread will load | |
| 1820 // the class. The other threads will find the loaded version once the | |
| 1821 // class is loaded. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1822 Klass* aos = _abstract_ownable_synchronizer_klass; |
| 0 | 1823 if (aos == NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1824 Klass* k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK); |
| 0 | 1825 // Force a fence to prevent any read before the write completes |
| 1826 OrderAccess::fence(); | |
| 1827 _abstract_ownable_synchronizer_klass = k; | |
| 1828 } | |
| 1829 } | |
| 1830 | |
| 1831 // ---------------------------------------------------------------------------- | |
| 1832 // Initialization | |
| 1833 | |
| 1834 void SystemDictionary::initialize(TRAPS) { | |
| 1835 // Allocate arrays | |
| 1836 assert(dictionary() == NULL, | |
| 1837 "SystemDictionary should only be initialized once"); | |
|
4864
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1838 _sdgeneration = 0; |
|
b2cd0ee8f778
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
4800
diff
changeset
|
1839 _dictionary = new Dictionary(calculate_systemdictionary_size(PredictedLoadedClassCount)); |
| 1903 | 1840 _placeholders = new PlaceholderTable(_nof_buckets); |
| 0 | 1841 _number_of_modifications = 0; |
| 1903 | 1842 _loader_constraints = new LoaderConstraintTable(_loader_constraint_size); |
| 1843 _resolution_errors = new ResolutionErrorTable(_resolution_error_size); | |
| 1844 _invoke_method_table = new SymbolPropertyTable(_invoke_method_size); | |
| 0 | 1845 |
| 1846 // Allocate private object used as system class loader lock | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1847 _system_loader_lock_obj = oopFactory::new_intArray(0, CHECK); |
| 0 | 1848 // Initialize basic classes |
| 1849 initialize_preloaded_classes(CHECK); | |
| 1850 } | |
| 1851 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1852 // Compact table of directions on the initialization of klasses: |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1853 static const short wk_init_info[] = { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1854 #define WK_KLASS_INIT_INFO(name, symbol, option) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1855 ( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1856 << SystemDictionary::CEIL_LG_OPTION_LIMIT) \ |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1857 | (int)SystemDictionary::option ), |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1858 WK_KLASSES_DO(WK_KLASS_INIT_INFO) |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1859 #undef WK_KLASS_INIT_INFO |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1860 0 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1861 }; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1862 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1863 bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1864 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1865 int info = wk_init_info[id - FIRST_WKID]; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1866 int sid = (info >> CEIL_LG_OPTION_LIMIT); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
1867 Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1868 Klass** klassp = &_well_known_klasses[id]; |
| 2460 | 1869 bool must_load = (init_opt < SystemDictionary::Opt); |
| 1870 bool try_load = true; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1871 if (init_opt == SystemDictionary::Opt_Kernel) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1872 #ifndef KERNEL |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1873 try_load = false; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1874 #endif //KERNEL |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1875 } |
| 2460 | 1876 if ((*klassp) == NULL && try_load) { |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1877 if (must_load) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1878 (*klassp) = resolve_or_fail(symbol, true, CHECK_0); // load required class |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1879 } else { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1880 (*klassp) = resolve_or_null(symbol, CHECK_0); // load optional klass |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1881 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1882 } |
| 2460 | 1883 return ((*klassp) != NULL); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1884 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1885 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1886 void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1887 assert((int)start_id <= (int)limit_id, "IDs are out of order!"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1888 for (int id = (int)start_id; id < (int)limit_id; id++) { |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1889 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1890 int info = wk_init_info[id - FIRST_WKID]; |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1891 int sid = (info >> CEIL_LG_OPTION_LIMIT); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1892 int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT)); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1893 |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1894 initialize_wk_klass((WKID)id, opt, CHECK); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1895 } |
| 710 | 1896 |
| 1897 // move the starting value forward to the limit: | |
| 1898 start_id = limit_id; | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1899 } |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1900 |
| 0 | 1901 void SystemDictionary::initialize_preloaded_classes(TRAPS) { |
| 1142 | 1902 assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once"); |
| 0 | 1903 // Preload commonly used klasses |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1904 WKID scan = FIRST_WKID; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1905 // first do Object, then String, Class |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1906 if (UseSharedSpaces) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1907 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1908 // Initialize the constant pool for the Object_class |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1909 InstanceKlass* ik = InstanceKlass::cast(Object_klass()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1910 ik->constants()->restore_unshareable_info(CHECK); |
|
6733
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
1911 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1912 } else { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1913 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1914 } |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1915 |
| 6057 | 1916 // Calculate offsets for String and Class classes since they are loaded and |
| 1917 // can be used after this point. | |
| 1918 java_lang_String::compute_offsets(); | |
| 3938 | 1919 java_lang_Class::compute_offsets(); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1920 |
| 0 | 1921 // Fixup mirrors for classes loaded before java.lang.Class. |
| 1922 // These calls iterate over the objects currently in the perm gen | |
| 1923 // so calling them at this point is matters (not before when there | |
| 1924 // are fewer objects and not later after there are more objects | |
| 1925 // in the perm gen. | |
| 1926 Universe::initialize_basic_type_mirrors(CHECK); | |
| 1927 Universe::fixup_mirrors(CHECK); | |
| 1928 | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1929 // do a bunch more: |
| 1142 | 1930 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK); |
| 0 | 1931 |
| 1932 // Preload ref klasses and set reference types | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1933 InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER); |
|
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
1934 InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass)); |
| 0 | 1935 |
| 1142 | 1936 initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1937 InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1938 InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1939 InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1940 InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM); |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1941 |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1942 // JSR 292 classes |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1943 WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass); |
|
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3785
diff
changeset
|
1944 WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass); |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1945 initialize_wk_klasses_until(jsr292_group_start, scan, CHECK); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1946 if (EnableInvokeDynamic) { |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1947 initialize_wk_klasses_through(jsr292_group_end, scan, CHECK); |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1948 } else { |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1949 // Skip the JSR 292 classes, if not enabled. |
|
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2357
diff
changeset
|
1950 scan = WKID(jsr292_group_end + 1); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1951 } |
| 710 | 1952 |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1953 initialize_wk_klasses_until(WKID_LIMIT, scan, CHECK); |
| 0 | 1954 |
| 1142 | 1955 _box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass); |
| 1956 _box_klasses[T_CHAR] = WK_KLASS(Character_klass); | |
| 1957 _box_klasses[T_FLOAT] = WK_KLASS(Float_klass); | |
| 1958 _box_klasses[T_DOUBLE] = WK_KLASS(Double_klass); | |
| 1959 _box_klasses[T_BYTE] = WK_KLASS(Byte_klass); | |
| 1960 _box_klasses[T_SHORT] = WK_KLASS(Short_klass); | |
| 1961 _box_klasses[T_INT] = WK_KLASS(Integer_klass); | |
| 1962 _box_klasses[T_LONG] = WK_KLASS(Long_klass); | |
|
132
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1963 //_box_klasses[T_OBJECT] = WK_KLASS(object_klass); |
|
60b728ec77c1
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
22
diff
changeset
|
1964 //_box_klasses[T_ARRAY] = WK_KLASS(object_klass); |
| 0 | 1965 |
| 1966 #ifdef KERNEL | |
| 3938 | 1967 if (DownloadManager_klass() == NULL) { |
| 0 | 1968 warning("Cannot find sun/jkernel/DownloadManager"); |
| 1969 } | |
| 1970 #endif // KERNEL | |
| 514 | 1971 |
| 0 | 1972 { // Compute whether we should use loadClass or loadClassInternal when loading classes. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1973 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature()); |
| 0 | 1974 _has_loadClassInternal = (method != NULL); |
| 1975 } | |
| 1976 { // Compute whether we should use checkPackageAccess or NOT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1977 Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature()); |
| 0 | 1978 _has_checkPackageAccess = (method != NULL); |
| 1979 } | |
| 1980 } | |
| 1981 | |
| 1982 // Tells if a given klass is a box (wrapper class, such as java.lang.Integer). | |
| 1983 // If so, returns the basic type it holds. If not, returns T_OBJECT. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1984 BasicType SystemDictionary::box_klass_type(Klass* k) { |
| 0 | 1985 assert(k != NULL, ""); |
| 1986 for (int i = T_BOOLEAN; i < T_VOID+1; i++) { | |
| 1987 if (_box_klasses[i] == k) | |
| 1988 return (BasicType)i; | |
| 1989 } | |
| 1990 return T_OBJECT; | |
| 1991 } | |
| 1992 | |
| 1993 // Constraints on class loaders. The details of the algorithm can be | |
| 1994 // found in the OOPSLA'98 paper "Dynamic Class Loading in the Java | |
| 1995 // Virtual Machine" by Sheng Liang and Gilad Bracha. The basic idea is | |
| 1996 // that the system dictionary needs to maintain a set of contraints that | |
| 1997 // must be satisfied by all classes in the dictionary. | |
| 1998 // if defining is true, then LinkageError if already in systemDictionary | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1999 // if initiating loader, then ok if InstanceKlass matches existing entry |
| 0 | 2000 |
| 2001 void SystemDictionary::check_constraints(int d_index, unsigned int d_hash, | |
| 2002 instanceKlassHandle k, | |
| 2003 Handle class_loader, bool defining, | |
| 2004 TRAPS) { | |
| 2005 const char *linkage_error = NULL; | |
| 2006 { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2007 Symbol* name = k->name(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2008 ClassLoaderData *loader_data = class_loader_data(class_loader); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2009 |
| 0 | 2010 MutexLocker mu(SystemDictionary_lock, THREAD); |
| 2011 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2012 Klass* check = find_class(d_index, d_hash, name, loader_data); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2013 if (check != (Klass*)NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2014 // if different InstanceKlass - duplicate class definition, |
| 0 | 2015 // else - ok, class loaded by a different thread in parallel, |
| 2016 // we should only have found it if it was done loading and ok to use | |
| 2017 // system dictionary only holds instance classes, placeholders | |
| 2018 // also holds array classes | |
| 2019 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2020 assert(check->oop_is_instance(), "noninstance in systemdictionary"); |
| 0 | 2021 if ((defining == true) || (k() != check)) { |
| 2022 linkage_error = "loader (instance of %s): attempted duplicate class " | |
| 2023 "definition for name: \"%s\""; | |
| 2024 } else { | |
| 2025 return; | |
| 2026 } | |
| 2027 } | |
| 2028 | |
| 2029 #ifdef ASSERT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2030 Symbol* ph_check = find_placeholder(name, loader_data); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2031 assert(ph_check == NULL || ph_check == name, "invalid symbol"); |
| 0 | 2032 #endif |
| 2033 | |
| 2034 if (linkage_error == NULL) { | |
| 2035 if (constraints()->check_or_update(k, class_loader, name) == false) { | |
| 2036 linkage_error = "loader constraint violation: loader (instance of %s)" | |
| 2037 " previously initiated loading for a different type with name \"%s\""; | |
| 2038 } | |
| 2039 } | |
| 2040 } | |
| 2041 | |
| 2042 // Throw error now if needed (cannot throw while holding | |
| 2043 // SystemDictionary_lock because of rank ordering) | |
| 2044 | |
| 2045 if (linkage_error) { | |
| 2046 ResourceMark rm(THREAD); | |
| 2047 const char* class_loader_name = loader_name(class_loader()); | |
| 2048 char* type_name = k->name()->as_C_string(); | |
| 2049 size_t buflen = strlen(linkage_error) + strlen(class_loader_name) + | |
| 2050 strlen(type_name); | |
| 2051 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
| 2052 jio_snprintf(buf, buflen, linkage_error, class_loader_name, type_name); | |
| 2053 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); | |
| 2054 } | |
| 2055 } | |
| 2056 | |
| 2057 | |
| 2058 // Update system dictionary - done after check_constraint and add_to_hierachy | |
| 2059 // have been called. | |
| 2060 void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash, | |
| 2061 int p_index, unsigned int p_hash, | |
| 2062 instanceKlassHandle k, | |
| 2063 Handle class_loader, | |
| 2064 TRAPS) { | |
| 2065 // Compile_lock prevents systemDictionary updates during compilations | |
| 2066 assert_locked_or_safepoint(Compile_lock); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2067 Symbol* name = k->name(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2068 ClassLoaderData *loader_data = class_loader_data(class_loader); |
| 0 | 2069 |
| 2070 { | |
| 2071 MutexLocker mu1(SystemDictionary_lock, THREAD); | |
| 2072 | |
| 2073 // See whether biased locking is enabled and if so set it for this | |
| 2074 // klass. | |
| 2075 // Note that this must be done past the last potential blocking | |
| 2076 // point / safepoint. We enable biased locking lazily using a | |
| 2077 // VM_Operation to iterate the SystemDictionary and installing the | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2078 // biasable mark word into each InstanceKlass's prototype header. |
| 0 | 2079 // To avoid race conditions where we accidentally miss enabling the |
| 2080 // optimization for one class in the process of being added to the | |
| 2081 // dictionary, we must not safepoint after the test of | |
| 2082 // BiasedLocking::enabled(). | |
| 2083 if (UseBiasedLocking && BiasedLocking::enabled()) { | |
| 2084 // Set biased locking bit for all loaded classes; it will be | |
| 2085 // cleared if revocation occurs too often for this type | |
| 2086 // NOTE that we must only do this when the class is initally | |
| 2087 // defined, not each time it is referenced from a new class loader | |
| 2088 if (k->class_loader() == class_loader()) { | |
| 2089 k->set_prototype_header(markOopDesc::biased_locking_prototype()); | |
| 2090 } | |
| 2091 } | |
| 2092 | |
|
4800
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2093 // Assign a classid if one has not already been assigned. The |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2094 // counter does not need to be atomically incremented since this |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2095 // is only done while holding the SystemDictionary_lock. |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2096 // All loaded classes get a unique ID. |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2097 TRACE_INIT_ID(k); |
|
94ec88ca68e2
7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents:
3938
diff
changeset
|
2098 |
| 0 | 2099 // Check for a placeholder. If there, remove it and make a |
| 2100 // new system dictionary entry. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2101 placeholders()->find_and_remove(p_index, p_hash, name, loader_data, THREAD); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2102 Klass* sd_check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 2103 if (sd_check == NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2104 dictionary()->add_klass(name, loader_data, k); |
| 0 | 2105 notice_modification(); |
| 2106 } | |
| 2107 #ifdef ASSERT | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2108 sd_check = find_class(d_index, d_hash, name, loader_data); |
| 0 | 2109 assert (sd_check != NULL, "should have entry in system dictionary"); |
| 2110 // Changed to allow PH to remain to complete class circularity checking | |
| 2111 // while only one thread can define a class at one time, multiple | |
| 2112 // classes can resolve the superclass for a class at one time, | |
| 2113 // and the placeholder is used to track that | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2114 // Symbol* ph_check = find_placeholder(name, class_loader); |
| 0 | 2115 // assert (ph_check == NULL, "should not have a placeholder entry"); |
| 2116 #endif | |
| 2117 SystemDictionary_lock->notify_all(); | |
| 2118 } | |
| 2119 } | |
| 2120 | |
| 2121 | |
|
2244
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
2122 // Try to find a class name using the loader constraints. The |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
2123 // loader constraints might know about a class that isn't fully loaded |
|
4f26f535a225
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
2177
diff
changeset
|
2124 // yet and these will be ignored. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2125 Klass* SystemDictionary::find_constrained_instance_or_array_klass( |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2126 Symbol* class_name, Handle class_loader, TRAPS) { |
| 0 | 2127 |
| 2128 // First see if it has been loaded directly. | |
| 2129 // Force the protection domain to be null. (This removes protection checks.) | |
| 2130 Handle no_protection_domain; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2131 Klass* klass = find_instance_or_array_klass(class_name, class_loader, |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
2132 no_protection_domain, CHECK_NULL); |
| 0 | 2133 if (klass != NULL) |
| 2134 return klass; | |
| 2135 | |
| 2136 // Now look to see if it has been loaded elsewhere, and is subject to | |
| 2137 // a loader constraint that would require this loader to return the | |
| 2138 // klass that is already loaded. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2139 if (FieldType::is_array(class_name)) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2140 // For array classes, their Klass*s are not kept in the |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2141 // constraint table. The element Klass*s are. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2142 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2143 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
| 0 | 2144 if (t != T_OBJECT) { |
| 2145 klass = Universe::typeArrayKlassObj(t); | |
| 2146 } else { | |
| 2147 MutexLocker mu(SystemDictionary_lock, THREAD); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2148 klass = constraints()->find_constrained_klass(fd.object_key(), class_loader); |
| 0 | 2149 } |
| 1336 | 2150 // If element class already loaded, allocate array klass |
| 0 | 2151 if (klass != NULL) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2152 klass = Klass::cast(klass)->array_klass_or_null(fd.dimension()); |
| 0 | 2153 } |
| 2154 } else { | |
| 2155 MutexLocker mu(SystemDictionary_lock, THREAD); | |
| 2156 // Non-array classes are easy: simply check the constraint table. | |
| 2157 klass = constraints()->find_constrained_klass(class_name, class_loader); | |
| 2158 } | |
| 2159 | |
| 2160 return klass; | |
| 2161 } | |
| 2162 | |
| 2163 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2164 bool SystemDictionary::add_loader_constraint(Symbol* class_name, |
| 0 | 2165 Handle class_loader1, |
| 2166 Handle class_loader2, | |
| 2167 Thread* THREAD) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2168 ClassLoaderData* loader_data1 = class_loader_data(class_loader1); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2169 ClassLoaderData* loader_data2 = class_loader_data(class_loader2); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2170 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2171 Symbol* constraint_name = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2172 if (!FieldType::is_array(class_name)) { |
| 1336 | 2173 constraint_name = class_name; |
| 2174 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2175 // For array classes, their Klass*s are not kept in the |
| 1336 | 2176 // constraint table. The element classes are. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2177 FieldArrayInfo fd; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2178 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false)); |
| 1336 | 2179 // primitive types always pass |
| 2180 if (t != T_OBJECT) { | |
| 2181 return true; | |
| 2182 } else { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2183 constraint_name = fd.object_key(); |
| 1336 | 2184 } |
| 2185 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2186 unsigned int d_hash1 = dictionary()->compute_hash(constraint_name, loader_data1); |
| 0 | 2187 int d_index1 = dictionary()->hash_to_index(d_hash1); |
| 2188 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2189 unsigned int d_hash2 = dictionary()->compute_hash(constraint_name, loader_data2); |
| 0 | 2190 int d_index2 = dictionary()->hash_to_index(d_hash2); |
| 2191 { | |
| 1336 | 2192 MutexLocker mu_s(SystemDictionary_lock, THREAD); |
| 0 | 2193 |
| 1336 | 2194 // Better never do a GC while we're holding these oops |
| 2195 No_Safepoint_Verifier nosafepoint; | |
| 0 | 2196 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2197 Klass* klass1 = find_class(d_index1, d_hash1, constraint_name, loader_data1); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2198 Klass* klass2 = find_class(d_index2, d_hash2, constraint_name, loader_data2); |
| 1336 | 2199 return constraints()->add_entry(constraint_name, klass1, class_loader1, |
| 2200 klass2, class_loader2); | |
| 0 | 2201 } |
| 2202 } | |
| 2203 | |
| 2204 // Add entry to resolution error table to record the error when the first | |
| 2205 // attempt to resolve a reference to a class has failed. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2206 void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, Symbol* error) { |
| 0 | 2207 unsigned int hash = resolution_errors()->compute_hash(pool, which); |
| 2208 int index = resolution_errors()->hash_to_index(hash); | |
| 2209 { | |
| 2210 MutexLocker ml(SystemDictionary_lock, Thread::current()); | |
| 2211 resolution_errors()->add_entry(index, hash, pool, which, error); | |
| 2212 } | |
| 2213 } | |
| 2214 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2215 // Delete a resolution error for RedefineClasses for a constant pool is going away |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2216 void SystemDictionary::delete_resolution_error(ConstantPool* pool) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2217 resolution_errors()->delete_entry(pool); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2218 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2219 |
| 0 | 2220 // Lookup resolution error table. Returns error if found, otherwise NULL. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2221 Symbol* SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) { |
| 0 | 2222 unsigned int hash = resolution_errors()->compute_hash(pool, which); |
| 2223 int index = resolution_errors()->hash_to_index(hash); | |
| 2224 { | |
| 2225 MutexLocker ml(SystemDictionary_lock, Thread::current()); | |
| 2226 ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2227 return (entry != NULL) ? entry->error() : (Symbol*)NULL; |
| 0 | 2228 } |
| 2229 } | |
| 2230 | |
| 2231 | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2232 // Signature constraints ensure that callers and callees agree about |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2233 // the meaning of type names in their signatures. This routine is the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2234 // intake for constraints. It collects them from several places: |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2235 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2236 // * LinkResolver::resolve_method (if check_access is true) requires |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2237 // that the resolving class (the caller) and the defining class of |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2238 // the resolved method (the callee) agree on each type in the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2239 // method's signature. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2240 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2241 // * LinkResolver::resolve_interface_method performs exactly the same |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2242 // checks. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2243 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2244 // * LinkResolver::resolve_field requires that the constant pool |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2245 // attempting to link to a field agree with the field's defining |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2246 // class about the type of the field signature. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2247 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2248 // * klassVtable::initialize_vtable requires that, when a class |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2249 // overrides a vtable entry allocated by a superclass, that the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2250 // overriding method (i.e., the callee) agree with the superclass |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2251 // on each type in the method's signature. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2252 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2253 // * klassItable::initialize_itable requires that, when a class fills |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2254 // in its itables, for each non-abstract method installed in an |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2255 // itable, the method (i.e., the callee) agree with the interface |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2256 // on each type in the method's signature. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2257 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2258 // All those methods have a boolean (check_access, checkconstraints) |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2259 // which turns off the checks. This is used from specialized contexts |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2260 // such as bootstrapping, dumping, and debugging. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2261 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2262 // No direct constraint is placed between the class and its |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2263 // supertypes. Constraints are only placed along linked relations |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2264 // between callers and callees. When a method overrides or implements |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2265 // an abstract method in a supertype (superclass or interface), the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2266 // constraints are placed as if the supertype were the caller to the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2267 // overriding method. (This works well, since callers to the |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2268 // supertype have already established agreement between themselves and |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2269 // the supertype.) As a result of all this, a class can disagree with |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2270 // its supertype about the meaning of a type name, as long as that |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2271 // class neither calls a relevant method of the supertype, nor is |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2272 // called (perhaps via an override) from the supertype. |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2273 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2274 // |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2275 // SystemDictionary::check_signature_loaders(sig, l1, l2) |
|
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2276 // |
| 0 | 2277 // Make sure all class components (including arrays) in the given |
| 2278 // signature will be resolved to the same class in both loaders. | |
| 2279 // Returns the name of the type that failed a loader constraint check, or | |
| 2280 // NULL if no constraint failed. The returned C string needs cleaning up | |
|
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
579
diff
changeset
|
2281 // with a ResourceMark in the caller. No exception except OOME is thrown. |
| 1336 | 2282 // Arrays are not added to the loader constraint table, their elements are. |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2283 char* SystemDictionary::check_signature_loaders(Symbol* signature, |
| 0 | 2284 Handle loader1, Handle loader2, |
| 2285 bool is_method, TRAPS) { | |
| 2286 // Nothing to do if loaders are the same. | |
| 2287 if (loader1() == loader2()) { | |
| 2288 return NULL; | |
| 2289 } | |
| 2290 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2291 ResourceMark rm(THREAD); |
| 0 | 2292 SignatureStream sig_strm(signature, is_method); |
| 2293 while (!sig_strm.is_done()) { | |
| 2294 if (sig_strm.is_object()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2295 Symbol* s = sig_strm.as_symbol(CHECK_NULL); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2296 Symbol* sig = s; |
| 0 | 2297 if (!add_loader_constraint(sig, loader1, loader2, THREAD)) { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2298 return sig->as_C_string(); |
| 0 | 2299 } |
| 2300 } | |
| 2301 sig_strm.next(); | |
| 2302 } | |
| 2303 return NULL; | |
| 2304 } | |
| 2305 | |
| 2306 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2307 methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2308 Symbol* signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2309 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2310 methodHandle empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2311 assert(EnableInvokeDynamic, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2312 assert(MethodHandles::is_signature_polymorphic(iid) && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2313 MethodHandles::is_signature_polymorphic_intrinsic(iid) && |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2314 iid != vmIntrinsics::_invokeGeneric, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2315 err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid))); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2316 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2317 unsigned int hash = invoke_method_table()->compute_hash(signature, iid); |
| 710 | 2318 int index = invoke_method_table()->hash_to_index(hash); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2319 SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2320 methodHandle m; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2321 if (spe == NULL || spe->method() == NULL) { |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2322 spe = NULL; |
| 710 | 2323 // Must create lots of stuff here, but outside of the SystemDictionary lock. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2324 m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty)); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2325 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2326 methodHandle(), CompileThreshold, "MH", CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2327 |
| 710 | 2328 // Now grab the lock. We might have to throw away the new method, |
| 2329 // if a racing thread has managed to install one at the same time. | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2330 { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2331 MutexLocker ml(SystemDictionary_lock, THREAD); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2332 spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
| 710 | 2333 if (spe == NULL) |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2334 spe = invoke_method_table()->add_entry(index, hash, signature, iid); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2335 if (spe->method() == NULL) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2336 spe->set_method(m()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2337 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2338 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2339 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2340 assert(spe != NULL && spe->method() != NULL, ""); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2341 return spe->method(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2342 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2343 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2344 // Helper for unpacking the return value from linkMethod and linkCallSite. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2345 static methodHandle unpack_method_and_appendix(Handle mname, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2346 objArrayHandle appendix_box, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2347 Handle* appendix_result, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2348 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2349 methodHandle empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2350 if (mname.not_null()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2351 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(mname()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2352 if (vmtarget != NULL && vmtarget->is_method()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2353 Method* m = (Method*)vmtarget; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2354 oop appendix = appendix_box->obj_at(0); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2355 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2356 #ifndef PRODUCT |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2357 tty->print("Linked method="INTPTR_FORMAT": ", m); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2358 m->print(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2359 if (appendix != NULL) { tty->print("appendix = "); appendix->print(); } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2360 tty->cr(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2361 #endif //PRODUCT |
|
3363
167b70ff3abc
6939861: JVM should handle more conversion operations
never
parents:
3245
diff
changeset
|
2362 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2363 (*appendix_result) = Handle(THREAD, appendix); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2364 return methodHandle(THREAD, m); |
| 710 | 2365 } |
| 2366 } | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2367 THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2368 return empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2369 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2370 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2371 methodHandle SystemDictionary::find_method_handle_invoker(Symbol* name, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2372 Symbol* signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2373 KlassHandle accessing_klass, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2374 Handle *appendix_result, |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2375 Handle *method_type_result, |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2376 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2377 methodHandle empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2378 assert(EnableInvokeDynamic, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2379 assert(!THREAD->is_Compiler_thread(), ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2380 Handle method_type = |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2381 SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2382 if (false) { // FIXME: Decide if the Java upcall should resolve signatures. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2383 method_type = java_lang_String::create_from_symbol(signature, CHECK_(empty)); |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2384 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2385 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2386 KlassHandle mh_klass = SystemDictionary::MethodHandle_klass(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2387 int ref_kind = JVM_REF_invokeVirtual; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2388 Handle name_str = StringTable::intern(name, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2389 objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2390 assert(appendix_box->obj_at(0) == NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2391 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2392 // call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2393 JavaCallArguments args; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2394 args.push_oop(accessing_klass()->java_mirror()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2395 args.push_int(ref_kind); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2396 args.push_oop(mh_klass()->java_mirror()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2397 args.push_oop(name_str()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2398 args.push_oop(method_type()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2399 args.push_oop(appendix_box()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2400 JavaValue result(T_OBJECT); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2401 JavaCalls::call_static(&result, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2402 SystemDictionary::MethodHandleNatives_klass(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2403 vmSymbols::linkMethod_name(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2404 vmSymbols::linkMethod_signature(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2405 &args, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2406 Handle mname(THREAD, (oop) result.get_jobject()); |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2407 (*method_type_result) = method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2408 return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD); |
| 710 | 2409 } |
| 2410 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2411 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
2412 // Ask Java code to find or construct a java.lang.invoke.MethodType for the given |
| 710 | 2413 // signature, as interpreted relative to the given class loader. |
| 2414 // Because of class loader constraints, all method handle usage must be | |
| 2415 // consistent with this loader. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2416 Handle SystemDictionary::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
|
2417 KlassHandle accessing_klass, |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1339
diff
changeset
|
2418 TRAPS) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2419 Handle empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2420 vmIntrinsics::ID null_iid = vmIntrinsics::_none; // distinct from all method handle invoker intrinsics |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2421 unsigned int hash = invoke_method_table()->compute_hash(signature, null_iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2422 int index = invoke_method_table()->hash_to_index(hash); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2423 SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2424 if (spe != NULL && spe->method_type() != NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2425 assert(java_lang_invoke_MethodType::is_instance(spe->method_type()), ""); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2426 return Handle(THREAD, spe->method_type()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2427 } else if (THREAD->is_Compiler_thread()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2428 warning("SystemDictionary::find_method_handle_type called from compiler thread"); // FIXME |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2429 return Handle(); // do not attempt from within compiler, unless it was cached |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2430 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2431 |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2432 Handle class_loader, protection_domain; |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2433 bool is_on_bcp = true; // keep this true as long as we can materialize from the boot classloader |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2434 int npts = ArgumentCount(signature).size(); |
| 1142 | 2435 objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty)); |
| 710 | 2436 int arg = 0; |
| 2437 Handle rt; // the return type from the signature | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2438 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2439 for (SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2440 oop mirror = NULL; |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2441 if (is_on_bcp) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2442 // Note: class_loader & protection_domain are both null at this point. |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2443 mirror = ss.as_java_mirror(class_loader, protection_domain, |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2444 SignatureStream::ReturnNull, CHECK_(empty)); |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2445 if (mirror == NULL) { |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2446 // fall back from BCP to accessing_klass |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2447 if (accessing_klass.not_null()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2448 class_loader = Handle(THREAD, InstanceKlass::cast(accessing_klass())->class_loader()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2449 protection_domain = Handle(THREAD, InstanceKlass::cast(accessing_klass())->protection_domain()); |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2450 } |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2451 is_on_bcp = false; |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2452 } |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2453 } |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2454 if (!is_on_bcp) { |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2455 // Resolve, throwing a real error if it doesn't work. |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2456 mirror = ss.as_java_mirror(class_loader, protection_domain, |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2457 SignatureStream::NCDFError, CHECK_(empty)); |
| 710 | 2458 } |
| 2459 if (ss.at_return_type()) | |
| 2460 rt = Handle(THREAD, mirror); | |
| 2461 else | |
| 2462 pts->obj_at_put(arg++, mirror); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2463 |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2464 // Check accessibility. |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2465 if (ss.is_object() && accessing_klass.not_null()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2466 Klass* sel_klass = java_lang_Class::as_Klass(mirror); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2467 mirror = NULL; // safety |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2468 // Emulate ConstantPool::verify_constant_pool_resolve. |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2469 if (Klass::cast(sel_klass)->oop_is_objArray()) |
|
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
2470 sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass(); |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2471 if (Klass::cast(sel_klass)->oop_is_instance()) { |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2472 KlassHandle sel_kh(THREAD, sel_klass); |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2473 LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty)); |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2474 } |
|
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2475 } |
| 710 | 2476 } |
| 2477 assert(arg == npts, ""); | |
| 2478 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
2479 // call java.lang.invoke.MethodHandleNatives::findMethodType(Class rt, Class[] pts) -> MethodType |
| 710 | 2480 JavaCallArguments args(Handle(THREAD, rt())); |
| 2481 args.push_oop(pts()); | |
| 2482 JavaValue result(T_OBJECT); | |
| 2483 JavaCalls::call_static(&result, | |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1339
diff
changeset
|
2484 SystemDictionary::MethodHandleNatives_klass(), |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1339
diff
changeset
|
2485 vmSymbols::findMethodHandleType_name(), |
| 2460 | 2486 vmSymbols::findMethodHandleType_signature(), |
| 710 | 2487 &args, CHECK_(empty)); |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
2488 Handle method_type(THREAD, (oop) result.get_jobject()); |
|
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
2489 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2490 if (is_on_bcp) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2491 // We can cache this MethodType inside the JVM. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2492 MutexLocker ml(SystemDictionary_lock, THREAD); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2493 spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2494 if (spe == NULL) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2495 spe = invoke_method_table()->add_entry(index, hash, signature, null_iid); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2496 if (spe->method_type() == NULL) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2497 spe->set_method_type(method_type()); |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
2498 } |
|
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
2499 } |
|
1508
2ffde6cfe049
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
1507
diff
changeset
|
2500 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2501 // report back to the caller with the MethodType |
|
1793
d257356e35f0
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
1660
diff
changeset
|
2502 return method_type; |
| 710 | 2503 } |
| 2504 | |
| 1602 | 2505 // Ask Java code to find or construct a method handle constant. |
| 2506 Handle SystemDictionary::link_method_handle_constant(KlassHandle caller, | |
| 2507 int ref_kind, //e.g., JVM_REF_invokeVirtual | |
| 2508 KlassHandle callee, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2509 Symbol* name_sym, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2510 Symbol* signature, |
| 1602 | 2511 TRAPS) { |
| 2512 Handle empty; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2513 Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty)); |
| 1602 | 2514 Handle type; |
| 2515 if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2516 type = find_method_handle_type(signature, caller, CHECK_(empty)); |
| 1602 | 2517 } else { |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2518 ResourceMark rm(THREAD); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2519 SignatureStream ss(signature, false); |
| 1602 | 2520 if (!ss.is_done()) { |
| 2521 oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(), | |
| 2522 SignatureStream::NCDFError, CHECK_(empty)); | |
| 2523 type = Handle(THREAD, mirror); | |
| 2524 ss.next(); | |
| 2525 if (!ss.is_done()) type = Handle(); // error! | |
| 2526 } | |
| 2527 } | |
| 2528 if (type.is_null()) { | |
| 2529 THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty); | |
| 2530 } | |
| 2531 | |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
2532 // call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle |
| 1602 | 2533 JavaCallArguments args; |
| 2534 args.push_oop(caller->java_mirror()); // the referring class | |
| 2535 args.push_int(ref_kind); | |
| 2536 args.push_oop(callee->java_mirror()); // the target class | |
| 2537 args.push_oop(name()); | |
| 2538 args.push_oop(type()); | |
| 2539 JavaValue result(T_OBJECT); | |
| 2540 JavaCalls::call_static(&result, | |
| 2541 SystemDictionary::MethodHandleNatives_klass(), | |
| 2542 vmSymbols::linkMethodHandleConstant_name(), | |
| 2460 | 2543 vmSymbols::linkMethodHandleConstant_signature(), |
| 1602 | 2544 &args, CHECK_(empty)); |
| 2545 return Handle(THREAD, (oop) result.get_jobject()); | |
| 2546 } | |
| 710 | 2547 |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2356
diff
changeset
|
2548 // Ask Java code to find or construct a java.lang.invoke.CallSite for the given |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2549 // name and signature, as interpreted relative to the given class loader. |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2550 methodHandle SystemDictionary::find_dynamic_call_site_invoker(KlassHandle caller, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2551 Handle bootstrap_specifier, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2552 Symbol* name, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2553 Symbol* type, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2554 Handle *appendix_result, |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2555 Handle *method_type_result, |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2556 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2557 methodHandle empty; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2558 Handle bsm, info; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2559 if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2560 bsm = bootstrap_specifier; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2561 } else { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2562 assert(bootstrap_specifier->is_objArray(), ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2563 objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2564 int len = args->length(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2565 assert(len >= 1, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2566 bsm = Handle(THREAD, args->obj_at(0)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2567 if (len > 1) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2568 objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2569 for (int i = 1; i < len; i++) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2570 args1->obj_at_put(i-1, args->obj_at(i)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2571 info = Handle(THREAD, args1); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2572 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2573 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2574 guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()), |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
2575 "caller must supply a valid BSM"); |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1602
diff
changeset
|
2576 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2577 Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2578 Handle method_type = find_method_handle_type(type, caller, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2579 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2580 objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2581 assert(appendix_box->obj_at(0) == NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2582 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2583 // call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2584 JavaCallArguments args; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2585 args.push_oop(caller->java_mirror()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2586 args.push_oop(bsm()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2587 args.push_oop(method_name()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2588 args.push_oop(method_type()); |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1339
diff
changeset
|
2589 args.push_oop(info()); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2590 args.push_oop(appendix_box); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2591 JavaValue result(T_OBJECT); |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2592 JavaCalls::call_static(&result, |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1339
diff
changeset
|
2593 SystemDictionary::MethodHandleNatives_klass(), |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2594 vmSymbols::linkCallSite_name(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2595 vmSymbols::linkCallSite_signature(), |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2596 &args, CHECK_(empty)); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2597 Handle mname(THREAD, (oop) result.get_jobject()); |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6751
diff
changeset
|
2598 (*method_type_result) = method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2599 return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2600 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
2601 |
| 0 | 2602 // Since the identity hash code for symbols changes when the symbols are |
| 2603 // moved from the regular perm gen (hash in the mark word) to the shared | |
| 2604 // spaces (hash is the address), the classes loaded into the dictionary | |
| 2605 // may be in the wrong buckets. | |
| 2606 | |
| 2607 void SystemDictionary::reorder_dictionary() { | |
| 2608 dictionary()->reorder_dictionary(); | |
| 2609 } | |
| 2610 | |
| 2611 | |
| 2612 void SystemDictionary::copy_buckets(char** top, char* end) { | |
| 2613 dictionary()->copy_buckets(top, end); | |
| 2614 } | |
| 2615 | |
| 2616 | |
| 2617 void SystemDictionary::copy_table(char** top, char* end) { | |
| 2618 dictionary()->copy_table(top, end); | |
| 2619 } | |
| 2620 | |
| 2621 | |
| 2622 void SystemDictionary::reverse() { | |
| 2623 dictionary()->reverse(); | |
| 2624 } | |
| 2625 | |
| 2626 int SystemDictionary::number_of_classes() { | |
| 2627 return dictionary()->number_of_entries(); | |
| 2628 } | |
| 2629 | |
| 2630 | |
| 2631 // ---------------------------------------------------------------------------- | |
| 2632 #ifndef PRODUCT | |
| 2633 | |
| 2634 void SystemDictionary::print() { | |
| 2635 dictionary()->print(); | |
| 2636 | |
| 2637 // Placeholders | |
| 2638 GCMutexLocker mu(SystemDictionary_lock); | |
| 2639 placeholders()->print(); | |
| 2640 | |
| 2641 // loader constraints - print under SD_lock | |
| 2642 constraints()->print(); | |
| 2643 } | |
| 2644 | |
| 2645 #endif | |
| 2646 | |
| 2647 void SystemDictionary::verify() { | |
| 2648 guarantee(dictionary() != NULL, "Verify of system dictionary failed"); | |
| 2649 guarantee(constraints() != NULL, | |
| 2650 "Verify of loader constraints failed"); | |
| 2651 guarantee(dictionary()->number_of_entries() >= 0 && | |
| 2652 placeholders()->number_of_entries() >= 0, | |
| 2653 "Verify of system dictionary failed"); | |
| 2654 | |
| 2655 // Verify dictionary | |
| 2656 dictionary()->verify(); | |
| 2657 | |
| 2658 GCMutexLocker mu(SystemDictionary_lock); | |
| 2659 placeholders()->verify(); | |
| 2660 | |
| 2661 // Verify constraint table | |
| 2662 guarantee(constraints() != NULL, "Verify of loader constraints failed"); | |
|
1258
38836cf1d8d2
6920977: G1: guarantee(k == probe->klass(),"klass should be in dictionary") fails
tonyp
parents:
1142
diff
changeset
|
2663 constraints()->verify(dictionary(), placeholders()); |
| 0 | 2664 } |
| 2665 | |
| 2666 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2667 void SystemDictionary::verify_obj_klass_present(Symbol* class_name, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2668 ClassLoaderData* loader_data) { |
| 0 | 2669 GCMutexLocker mu(SystemDictionary_lock); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2670 Symbol* name; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2671 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2672 Klass* probe = find_class(class_name, loader_data); |
| 0 | 2673 if (probe == NULL) { |
| 2674 probe = SystemDictionary::find_shared_class(class_name); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2675 if (probe == NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2676 name = find_placeholder(class_name, loader_data); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2677 } |
| 0 | 2678 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2679 guarantee(probe != NULL || name != NULL, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2001
diff
changeset
|
2680 "Loaded klasses should be in SystemDictionary"); |
| 0 | 2681 } |
| 2682 | |
| 2683 #ifndef PRODUCT | |
| 2684 | |
| 2685 // statistics code | |
| 2686 class ClassStatistics: AllStatic { | |
| 2687 private: | |
| 2688 static int nclasses; // number of classes | |
| 2689 static int nmethods; // number of methods | |
| 2690 static int nmethoddata; // number of methodData | |
| 2691 static int class_size; // size of class objects in words | |
| 2692 static int method_size; // size of method objects in words | |
| 2693 static int debug_size; // size of debug info in methods | |
| 2694 static int methoddata_size; // size of methodData objects in words | |
| 2695 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2696 static void do_class(Klass* k) { |
| 0 | 2697 nclasses++; |
| 2698 class_size += k->size(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2699 if (k->oop_is_instance()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2700 InstanceKlass* ik = (InstanceKlass*)k; |
| 0 | 2701 class_size += ik->methods()->size(); |
| 2702 class_size += ik->constants()->size(); | |
| 2703 class_size += ik->local_interfaces()->size(); | |
| 2704 class_size += ik->transitive_interfaces()->size(); | |
| 2705 // We do not have to count implementors, since we only store one! | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2706 // SSS: How should these be accounted now that they have moved? |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2707 // class_size += ik->fields()->length(); |
| 0 | 2708 } |
| 2709 } | |
| 2710 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2711 static void do_method(Method* m) { |
| 0 | 2712 nmethods++; |
| 2713 method_size += m->size(); | |
| 2714 // class loader uses same objArray for empty vectors, so don't count these | |
| 2715 if (m->has_stackmap_table()) { | |
| 2716 method_size += m->stackmap_data()->size(); | |
| 2717 } | |
| 2718 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2719 MethodData* mdo = m->method_data(); |
| 0 | 2720 if (mdo != NULL) { |
| 2721 nmethoddata++; | |
| 2722 methoddata_size += mdo->size(); | |
| 2723 } | |
| 2724 } | |
| 2725 | |
| 2726 public: | |
| 2727 static void print() { | |
| 2728 SystemDictionary::classes_do(do_class); | |
| 2729 SystemDictionary::methods_do(do_method); | |
| 2730 tty->print_cr("Class statistics:"); | |
| 2731 tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize); | |
| 2732 tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods, | |
| 2733 (method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize); | |
| 2734 tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize); | |
| 2735 } | |
| 2736 }; | |
| 2737 | |
| 2738 | |
| 2739 int ClassStatistics::nclasses = 0; | |
| 2740 int ClassStatistics::nmethods = 0; | |
| 2741 int ClassStatistics::nmethoddata = 0; | |
| 2742 int ClassStatistics::class_size = 0; | |
| 2743 int ClassStatistics::method_size = 0; | |
| 2744 int ClassStatistics::debug_size = 0; | |
| 2745 int ClassStatistics::methoddata_size = 0; | |
| 2746 | |
| 2747 void SystemDictionary::print_class_statistics() { | |
| 2748 ResourceMark rm; | |
| 2749 ClassStatistics::print(); | |
| 2750 } | |
| 2751 | |
| 2752 | |
| 2753 class MethodStatistics: AllStatic { | |
| 2754 public: | |
| 2755 enum { | |
| 2756 max_parameter_size = 10 | |
| 2757 }; | |
| 2758 private: | |
| 2759 | |
| 2760 static int _number_of_methods; | |
| 2761 static int _number_of_final_methods; | |
| 2762 static int _number_of_static_methods; | |
| 2763 static int _number_of_native_methods; | |
| 2764 static int _number_of_synchronized_methods; | |
| 2765 static int _number_of_profiled_methods; | |
| 2766 static int _number_of_bytecodes; | |
| 2767 static int _parameter_size_profile[max_parameter_size]; | |
| 2768 static int _bytecodes_profile[Bytecodes::number_of_java_codes]; | |
| 2769 | |
| 2770 static void initialize() { | |
| 2771 _number_of_methods = 0; | |
| 2772 _number_of_final_methods = 0; | |
| 2773 _number_of_static_methods = 0; | |
| 2774 _number_of_native_methods = 0; | |
| 2775 _number_of_synchronized_methods = 0; | |
| 2776 _number_of_profiled_methods = 0; | |
| 2777 _number_of_bytecodes = 0; | |
| 2778 for (int i = 0; i < max_parameter_size ; i++) _parameter_size_profile[i] = 0; | |
| 2779 for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile [j] = 0; | |
| 2780 }; | |
| 2781 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2782 static void do_method(Method* m) { |
| 0 | 2783 _number_of_methods++; |
| 2784 // collect flag info | |
| 2785 if (m->is_final() ) _number_of_final_methods++; | |
| 2786 if (m->is_static() ) _number_of_static_methods++; | |
| 2787 if (m->is_native() ) _number_of_native_methods++; | |
| 2788 if (m->is_synchronized()) _number_of_synchronized_methods++; | |
| 2789 if (m->method_data() != NULL) _number_of_profiled_methods++; | |
| 2790 // collect parameter size info (add one for receiver, if any) | |
| 2791 _parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++; | |
| 2792 // collect bytecodes info | |
| 2793 { | |
| 2794 Thread *thread = Thread::current(); | |
| 2795 HandleMark hm(thread); | |
| 2796 BytecodeStream s(methodHandle(thread, m)); | |
| 2797 Bytecodes::Code c; | |
| 2798 while ((c = s.next()) >= 0) { | |
| 2799 _number_of_bytecodes++; | |
| 2800 _bytecodes_profile[c]++; | |
| 2801 } | |
| 2802 } | |
| 2803 } | |
| 2804 | |
| 2805 public: | |
| 2806 static void print() { | |
| 2807 initialize(); | |
| 2808 SystemDictionary::methods_do(do_method); | |
| 2809 // generate output | |
| 2810 tty->cr(); | |
| 2811 tty->print_cr("Method statistics (static):"); | |
| 2812 // flag distribution | |
| 2813 tty->cr(); | |
| 2814 tty->print_cr("%6d final methods %6.1f%%", _number_of_final_methods , _number_of_final_methods * 100.0F / _number_of_methods); | |
| 2815 tty->print_cr("%6d static methods %6.1f%%", _number_of_static_methods , _number_of_static_methods * 100.0F / _number_of_methods); | |
| 2816 tty->print_cr("%6d native methods %6.1f%%", _number_of_native_methods , _number_of_native_methods * 100.0F / _number_of_methods); | |
| 2817 tty->print_cr("%6d synchronized methods %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods); | |
| 2818 tty->print_cr("%6d profiled methods %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods); | |
| 2819 // parameter size profile | |
| 2820 tty->cr(); | |
| 2821 { int tot = 0; | |
| 2822 int avg = 0; | |
| 2823 for (int i = 0; i < max_parameter_size; i++) { | |
| 2824 int n = _parameter_size_profile[i]; | |
| 2825 tot += n; | |
| 2826 avg += n*i; | |
| 2827 tty->print_cr("parameter size = %1d: %6d methods %5.1f%%", i, n, n * 100.0F / _number_of_methods); | |
| 2828 } | |
| 2829 assert(tot == _number_of_methods, "should be the same"); | |
| 2830 tty->print_cr(" %6d methods 100.0%%", _number_of_methods); | |
| 2831 tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods); | |
| 2832 } | |
| 2833 // bytecodes profile | |
| 2834 tty->cr(); | |
| 2835 { int tot = 0; | |
| 2836 for (int i = 0; i < Bytecodes::number_of_java_codes; i++) { | |
| 2837 if (Bytecodes::is_defined(i)) { | |
| 2838 Bytecodes::Code c = Bytecodes::cast(i); | |
| 2839 int n = _bytecodes_profile[c]; | |
| 2840 tot += n; | |
| 2841 tty->print_cr("%9d %7.3f%% %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c)); | |
| 2842 } | |
| 2843 } | |
| 2844 assert(tot == _number_of_bytecodes, "should be the same"); | |
| 2845 tty->print_cr("%9d 100.000%%", _number_of_bytecodes); | |
| 2846 } | |
| 2847 tty->cr(); | |
| 2848 } | |
| 2849 }; | |
| 2850 | |
| 2851 int MethodStatistics::_number_of_methods; | |
| 2852 int MethodStatistics::_number_of_final_methods; | |
| 2853 int MethodStatistics::_number_of_static_methods; | |
| 2854 int MethodStatistics::_number_of_native_methods; | |
| 2855 int MethodStatistics::_number_of_synchronized_methods; | |
| 2856 int MethodStatistics::_number_of_profiled_methods; | |
| 2857 int MethodStatistics::_number_of_bytecodes; | |
| 2858 int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size]; | |
| 2859 int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes]; | |
| 2860 | |
| 2861 | |
| 2862 void SystemDictionary::print_method_statistics() { | |
| 2863 MethodStatistics::print(); | |
| 2864 } | |
| 2865 | |
| 2866 #endif // PRODUCT |