author | coleenp |
Thu, 03 Aug 2017 08:16:00 -0400 | |
changeset 46747 | 7b6570052b58 |
parent 46746 | ea379ebb9447 |
child 46994 | 7663ce98384b |
permissions | -rw-r--r-- |
1 | 1 |
/* |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2 |
* Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5421
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5421
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5421
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
42650 | 26 |
#include "aot/aotLoader.hpp" |
34666 | 27 |
#include "classfile/classFileParser.hpp" |
28 |
#include "classfile/classFileStream.hpp" |
|
29 |
#include "classfile/classLoader.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
30 |
#include "classfile/classLoaderData.inline.hpp" |
34666 | 31 |
#include "classfile/classLoaderExt.hpp" |
7397 | 32 |
#include "classfile/dictionary.hpp" |
29081
c61eb4914428
8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents:
28510
diff
changeset
|
33 |
#include "classfile/javaClasses.inline.hpp" |
34666 | 34 |
#include "classfile/klassFactory.hpp" |
7397 | 35 |
#include "classfile/loaderConstraints.hpp" |
36508 | 36 |
#include "classfile/packageEntry.hpp" |
7397 | 37 |
#include "classfile/placeholders.hpp" |
46729 | 38 |
#include "classfile/protectionDomainCache.hpp" |
7397 | 39 |
#include "classfile/resolutionErrors.hpp" |
24426
0a69c8cdfca9
8038654: Separate SymbolTable and StringTable code
gziemski
parents:
24334
diff
changeset
|
40 |
#include "classfile/stringTable.hpp" |
7397 | 41 |
#include "classfile/systemDictionary.hpp" |
42 |
#include "classfile/vmSymbols.hpp" |
|
28374
0558e321c027
8067836: The Universe::flush_foo methods belong in CodeCache.
coleenp
parents:
27694
diff
changeset
|
43 |
#include "code/codeCache.hpp" |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
44 |
#include "compiler/compileBroker.hpp" |
30764 | 45 |
#include "gc/shared/gcLocker.hpp" |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
46 |
#include "gc/shared/gcTraceTime.inline.hpp" |
7397 | 47 |
#include "interpreter/bytecodeStream.hpp" |
48 |
#include "interpreter/interpreter.hpp" |
|
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
49 |
#include "logging/log.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
50 |
#include "logging/logStream.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
51 |
#include "memory/filemap.hpp" |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
52 |
#include "memory/metaspaceClosure.hpp" |
7397 | 53 |
#include "memory/oopFactory.hpp" |
37248 | 54 |
#include "memory/resourceArea.hpp" |
7397 | 55 |
#include "oops/instanceKlass.hpp" |
56 |
#include "oops/instanceRefKlass.hpp" |
|
57 |
#include "oops/klass.inline.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
58 |
#include "oops/methodData.hpp" |
7397 | 59 |
#include "oops/objArrayKlass.hpp" |
29081
c61eb4914428
8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents:
28510
diff
changeset
|
60 |
#include "oops/objArrayOop.inline.hpp" |
7397 | 61 |
#include "oops/oop.inline.hpp" |
36508 | 62 |
#include "oops/symbol.hpp" |
7397 | 63 |
#include "oops/typeArrayKlass.hpp" |
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46505
diff
changeset
|
64 |
#include "prims/jvm.h" |
7397 | 65 |
#include "prims/jvmtiEnvBase.hpp" |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
66 |
#include "prims/resolvedMethodTable.hpp" |
7397 | 67 |
#include "prims/methodHandles.hpp" |
26585
2048b8d90c91
8058092: Test vm/mlvm/meth/stress/compiler/deoptimize. Assert in src/share/vm/classfile/systemDictionary.cpp: MH intrinsic invariant
iveresov
parents:
26583
diff
changeset
|
68 |
#include "runtime/arguments.hpp" |
7397 | 69 |
#include "runtime/biasedLocking.hpp" |
70 |
#include "runtime/fieldType.hpp" |
|
71 |
#include "runtime/handles.inline.hpp" |
|
72 |
#include "runtime/java.hpp" |
|
73 |
#include "runtime/javaCalls.hpp" |
|
74 |
#include "runtime/mutexLocker.hpp" |
|
24351
61b33cc6d3cf
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
24322
diff
changeset
|
75 |
#include "runtime/orderAccess.inline.hpp" |
7397 | 76 |
#include "runtime/signature.hpp" |
77 |
#include "services/classLoadingService.hpp" |
|
46742 | 78 |
#include "services/diagnosticCommand.hpp" |
7397 | 79 |
#include "services/threadService.hpp" |
37175
ac6850d71f72
8152119: Event-based tracing to allow for tracing Klass definition
mgronlun
parents:
36381
diff
changeset
|
80 |
#include "trace/traceMacros.hpp" |
21767
41eaa9a17059
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
21103
diff
changeset
|
81 |
#include "utilities/macros.hpp" |
41eaa9a17059
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
21103
diff
changeset
|
82 |
#include "utilities/ticks.hpp" |
27683
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27680
diff
changeset
|
83 |
#if INCLUDE_CDS |
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27680
diff
changeset
|
84 |
#include "classfile/sharedClassUtil.hpp" |
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27680
diff
changeset
|
85 |
#include "classfile/systemDictionaryShared.hpp" |
1d5707553fff
8064580: Move INCLUDE_CDS include section to the end of the include list
stefank
parents:
27680
diff
changeset
|
86 |
#endif |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
87 |
#if INCLUDE_JVMCI |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
88 |
#include "jvmci/jvmciRuntime.hpp" |
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
89 |
#endif |
18025 | 90 |
#if INCLUDE_TRACE |
27673
df559a888b9f
8065361: Fixup headers and definitions for INCLUDE_TRACE
mgronlun
parents:
27247
diff
changeset
|
91 |
#include "trace/tracing.hpp" |
18025 | 92 |
#endif |
93 |
||
7104 | 94 |
PlaceholderTable* SystemDictionary::_placeholders = NULL; |
95 |
Dictionary* SystemDictionary::_shared_dictionary = NULL; |
|
96 |
LoaderConstraintTable* SystemDictionary::_loader_constraints = NULL; |
|
97 |
ResolutionErrorTable* SystemDictionary::_resolution_errors = NULL; |
|
98 |
SymbolPropertyTable* SystemDictionary::_invoke_method_table = NULL; |
|
46729 | 99 |
ProtectionDomainCacheTable* SystemDictionary::_pd_cache_table = NULL; |
1 | 100 |
|
101 |
int SystemDictionary::_number_of_modifications = 0; |
|
102 |
oop SystemDictionary::_system_loader_lock_obj = NULL; |
|
103 |
||
33602 | 104 |
InstanceKlass* SystemDictionary::_well_known_klasses[SystemDictionary::WKID_LIMIT] |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
105 |
= { NULL /*, NULL...*/ }; |
1 | 106 |
|
33602 | 107 |
InstanceKlass* SystemDictionary::_box_klasses[T_VOID+1] = { NULL /*, NULL...*/ }; |
1 | 108 |
|
109 |
oop SystemDictionary::_java_system_loader = NULL; |
|
110 |
||
111 |
bool SystemDictionary::_has_loadClassInternal = false; |
|
112 |
bool SystemDictionary::_has_checkPackageAccess = false; |
|
113 |
||
114 |
// lazily initialized klass variables |
|
33602 | 115 |
InstanceKlass* volatile SystemDictionary::_abstract_ownable_synchronizer_klass = NULL; |
1 | 116 |
|
46729 | 117 |
// Default ProtectionDomainCacheSize value |
118 |
||
119 |
const int defaultProtectionDomainCacheSize = 1009; |
|
120 |
||
1 | 121 |
|
122 |
// ---------------------------------------------------------------------------- |
|
123 |
// Java-level SystemLoader |
|
124 |
||
125 |
oop SystemDictionary::java_system_loader() { |
|
126 |
return _java_system_loader; |
|
127 |
} |
|
128 |
||
129 |
void SystemDictionary::compute_java_system_loader(TRAPS) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
130 |
Klass* system_klass = WK_KLASS(ClassLoader_klass); |
1 | 131 |
JavaValue result(T_OBJECT); |
132 |
JavaCalls::call_static(&result, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
133 |
WK_KLASS(ClassLoader_klass), |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
134 |
vmSymbols::getSystemClassLoader_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
135 |
vmSymbols::void_classloader_signature(), |
1 | 136 |
CHECK); |
137 |
||
138 |
_java_system_loader = (oop)result.get_jobject(); |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
139 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
140 |
CDS_ONLY(SystemDictionaryShared::initialize(CHECK);) |
1 | 141 |
} |
142 |
||
143 |
||
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
144 |
ClassLoaderData* SystemDictionary::register_loader(Handle class_loader, TRAPS) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
145 |
if (class_loader() == NULL) return ClassLoaderData::the_null_class_loader_data(); |
27680
8ecc0871c18e
8064811: Use THREAD instead of CHECK_NULL in return statements
stefank
parents:
27677
diff
changeset
|
146 |
return ClassLoaderDataGraph::find_or_create(class_loader, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
147 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
148 |
|
1 | 149 |
// ---------------------------------------------------------------------------- |
1890 | 150 |
// Parallel class loading check |
151 |
||
152 |
bool SystemDictionary::is_parallelCapable(Handle class_loader) { |
|
153 |
if (UnsyncloadClass || class_loader.is_null()) return true; |
|
154 |
if (AlwaysLockClassLoader) return false; |
|
10546 | 155 |
return java_lang_ClassLoader::parallelCapable(class_loader()); |
1890 | 156 |
} |
157 |
// ---------------------------------------------------------------------------- |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
158 |
// ParallelDefineClass flag does not apply to bootclass loader |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
159 |
bool SystemDictionary::is_parallelDefine(Handle class_loader) { |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
160 |
if (class_loader.is_null()) return false; |
10546 | 161 |
if (AllowParallelDefineClass && java_lang_ClassLoader::parallelCapable(class_loader())) { |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
162 |
return true; |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
163 |
} |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
164 |
return false; |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
165 |
} |
16617
6235d2c7549f
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
16352
diff
changeset
|
166 |
|
39616
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
167 |
// Returns true if the passed class loader is the builtin application class loader |
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
168 |
// or a custom system class loader. A customer system class loader can be |
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
169 |
// specified via -Djava.system.class.loader. |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
170 |
bool SystemDictionary::is_system_class_loader(oop class_loader) { |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
171 |
if (class_loader == NULL) { |
39616
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
172 |
return false; |
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
173 |
} |
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
174 |
return (class_loader->klass() == SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass() || |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
175 |
class_loader == _java_system_loader); |
39616
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
176 |
} |
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
177 |
|
f82b1f888578
8159262: Walking PackageEntry Export and ModuleEntry Reads Must Occur Only When Neccessary And Wait Until ClassLoader's Aliveness Determined
lfoltan
parents:
39216
diff
changeset
|
178 |
// Returns true if the passed class loader is the platform class loader. |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
179 |
bool SystemDictionary::is_platform_class_loader(oop class_loader) { |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
180 |
if (class_loader == NULL) { |
16617
6235d2c7549f
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
16352
diff
changeset
|
181 |
return false; |
6235d2c7549f
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
16352
diff
changeset
|
182 |
} |
36508 | 183 |
return (class_loader->klass() == SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass()); |
16617
6235d2c7549f
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
16352
diff
changeset
|
184 |
} |
6235d2c7549f
7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents:
16352
diff
changeset
|
185 |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
186 |
// ---------------------------------------------------------------------------- |
1 | 187 |
// Resolving of classes |
188 |
||
189 |
// Forwards to resolve_or_null |
|
190 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
191 |
Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
192 |
Klass* klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD); |
1 | 193 |
if (HAS_PENDING_EXCEPTION || klass == NULL) { |
194 |
// can return a null klass |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
195 |
klass = handle_resolution_exception(class_name, throw_error, klass, THREAD); |
1 | 196 |
} |
197 |
return klass; |
|
198 |
} |
|
199 |
||
24334
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
200 |
Klass* SystemDictionary::handle_resolution_exception(Symbol* class_name, |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
201 |
bool throw_error, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
202 |
Klass* klass, TRAPS) { |
1 | 203 |
if (HAS_PENDING_EXCEPTION) { |
204 |
// If we have a pending exception we forward it to the caller, unless throw_error is true, |
|
205 |
// in which case we have to check whether the pending exception is a ClassNotFoundException, |
|
206 |
// and if so convert it to a NoClassDefFoundError |
|
207 |
// And chain the original ClassNotFoundException |
|
4571 | 208 |
if (throw_error && PENDING_EXCEPTION->is_a(SystemDictionary::ClassNotFoundException_klass())) { |
1 | 209 |
ResourceMark rm(THREAD); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
210 |
assert(klass == NULL, "Should not have result with exception pending"); |
1 | 211 |
Handle e(THREAD, PENDING_EXCEPTION); |
212 |
CLEAR_PENDING_EXCEPTION; |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
213 |
THROW_MSG_CAUSE_NULL(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string(), e); |
1 | 214 |
} else { |
215 |
return NULL; |
|
216 |
} |
|
217 |
} |
|
218 |
// Class not found, throw appropriate error or exception depending on value of throw_error |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
219 |
if (klass == NULL) { |
1 | 220 |
ResourceMark rm(THREAD); |
221 |
if (throw_error) { |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
222 |
THROW_MSG_NULL(vmSymbols::java_lang_NoClassDefFoundError(), class_name->as_C_string()); |
1 | 223 |
} else { |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
224 |
THROW_MSG_NULL(vmSymbols::java_lang_ClassNotFoundException(), class_name->as_C_string()); |
1 | 225 |
} |
226 |
} |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
227 |
return klass; |
1 | 228 |
} |
229 |
||
230 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
231 |
Klass* SystemDictionary::resolve_or_fail(Symbol* class_name, |
1 | 232 |
bool throw_error, TRAPS) |
233 |
{ |
|
234 |
return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD); |
|
235 |
} |
|
236 |
||
237 |
||
238 |
// Forwards to resolve_instance_class_or_null |
|
239 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
240 |
Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) { |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
241 |
assert(THREAD->can_call_java(), |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32349
diff
changeset
|
242 |
"can not load classes with compiler thread: class=%s, classloader=%s", |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32349
diff
changeset
|
243 |
class_name->as_C_string(), |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32349
diff
changeset
|
244 |
class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string()); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
245 |
if (FieldType::is_array(class_name)) { |
27677 | 246 |
return resolve_array_class_or_null(class_name, class_loader, protection_domain, THREAD); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
247 |
} else if (FieldType::is_obj(class_name)) { |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
248 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
249 |
// Ignore wrapping L and ;. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
250 |
TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
251 |
class_name->utf8_length() - 2, CHECK_NULL); |
27677 | 252 |
return resolve_instance_class_or_null(name, class_loader, protection_domain, THREAD); |
1 | 253 |
} else { |
27677 | 254 |
return resolve_instance_class_or_null(class_name, class_loader, protection_domain, THREAD); |
1 | 255 |
} |
256 |
} |
|
257 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
258 |
Klass* SystemDictionary::resolve_or_null(Symbol* class_name, TRAPS) { |
1 | 259 |
return resolve_or_null(class_name, Handle(), Handle(), THREAD); |
260 |
} |
|
261 |
||
262 |
// Forwards to resolve_instance_class_or_null |
|
263 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
264 |
Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
265 |
Handle class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
266 |
Handle protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
267 |
TRAPS) { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
268 |
assert(FieldType::is_array(class_name), "must be array"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
269 |
Klass* k = NULL; |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
270 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
271 |
// dimension and object_key in FieldArrayInfo are assigned as a side-effect |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
272 |
// of this call |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
273 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_NULL); |
1 | 274 |
if (t == T_OBJECT) { |
275 |
// naked oop "k" is OK here -- we assign back into it |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
276 |
k = SystemDictionary::resolve_instance_class_or_null(fd.object_key(), |
1 | 277 |
class_loader, |
278 |
protection_domain, |
|
279 |
CHECK_NULL); |
|
280 |
if (k != NULL) { |
|
14488 | 281 |
k = k->array_klass(fd.dimension(), CHECK_NULL); |
1 | 282 |
} |
283 |
} else { |
|
284 |
k = Universe::typeArrayKlassObj(t); |
|
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
285 |
k = TypeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL); |
1 | 286 |
} |
287 |
return k; |
|
288 |
} |
|
289 |
||
290 |
||
291 |
// Must be called for any super-class or super-interface resolution |
|
292 |
// during class definition to allow class circularity checking |
|
293 |
// super-interface callers: |
|
294 |
// parse_interfaces - for defineClass & jvmtiRedefineClasses |
|
295 |
// super-class callers: |
|
296 |
// ClassFileParser - for defineClass & jvmtiRedefineClasses |
|
297 |
// load_shared_class - while loading a class from shared archive |
|
1890 | 298 |
// resolve_instance_class_or_null: |
299 |
// via: handle_parallel_super_load |
|
1 | 300 |
// when resolving a class that has an existing placeholder with |
301 |
// a saved superclass [i.e. a defineClass is currently in progress] |
|
302 |
// if another thread is trying to resolve the class, it must do |
|
303 |
// super-class checks on its own thread to catch class circularity |
|
304 |
// This last call is critical in class circularity checking for cases |
|
305 |
// where classloading is delegated to different threads and the |
|
306 |
// classloader lock is released. |
|
307 |
// Take the case: Base->Super->Base |
|
308 |
// 1. If thread T1 tries to do a defineClass of class Base |
|
309 |
// resolve_super_or_fail creates placeholder: T1, Base (super Super) |
|
310 |
// 2. resolve_instance_class_or_null does not find SD or placeholder for Super |
|
311 |
// so it tries to load Super |
|
312 |
// 3. If we load the class internally, or user classloader uses same thread |
|
313 |
// loadClassFromxxx or defineClass via parseClassFile Super ... |
|
314 |
// 3.1 resolve_super_or_fail creates placeholder: T1, Super (super Base) |
|
315 |
// 3.3 resolve_instance_class_or_null Base, finds placeholder for Base |
|
316 |
// 3.4 calls resolve_super_or_fail Base |
|
317 |
// 3.5 finds T1,Base -> throws class circularity |
|
318 |
//OR 4. If T2 tries to resolve Super via defineClass Super ... |
|
319 |
// 4.1 resolve_super_or_fail creates placeholder: T2, Super (super Base) |
|
320 |
// 4.2 resolve_instance_class_or_null Base, finds placeholder for Base (super Super) |
|
321 |
// 4.3 calls resolve_super_or_fail Super in parallel on own thread T2 |
|
322 |
// 4.4 finds T2, Super -> throws class circularity |
|
323 |
// Must be called, even if superclass is null, since this is |
|
324 |
// where the placeholder entry is created which claims this |
|
325 |
// thread is loading this class/classloader. |
|
40016 | 326 |
// Be careful when modifying this code: once you have run |
327 |
// placeholders()->find_and_add(PlaceholderTable::LOAD_SUPER), |
|
328 |
// you need to find_and_remove it before returning. |
|
329 |
// So be careful to not exit with a CHECK_ macro betweeen these calls. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
330 |
Klass* SystemDictionary::resolve_super_or_fail(Symbol* child_name, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
331 |
Symbol* class_name, |
1 | 332 |
Handle class_loader, |
333 |
Handle protection_domain, |
|
334 |
bool is_superclass, |
|
335 |
TRAPS) { |
|
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
336 |
#if INCLUDE_CDS |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
337 |
if (DumpSharedSpaces) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
338 |
// Special processing for CDS dump time. |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
339 |
Klass* k = SystemDictionaryShared::dump_time_resolve_super_or_fail(child_name, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
340 |
class_name, class_loader, protection_domain, is_superclass, CHECK_NULL); |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
341 |
if (k) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
342 |
return k; |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
343 |
} |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
344 |
} |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
345 |
#endif // INCLUDE_CDS |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
346 |
|
1 | 347 |
// Double-check, if child class is already loaded, just return super-class,interface |
46729 | 348 |
// Don't add a placedholder if already loaded, i.e. already in appropriate class loader |
349 |
// dictionary. |
|
1 | 350 |
// Make sure there's a placeholder for the *child* before resolving. |
351 |
// Used as a claim that this thread is currently loading superclass/classloader |
|
352 |
// Used here for ClassCircularity checks and also for heap verification |
|
46729 | 353 |
// (every InstanceKlass needs to be in its class loader dictionary or have a placeholder). |
354 |
// Must check ClassCircularity before checking if super class is already loaded. |
|
1 | 355 |
// |
356 |
// We might not already have a placeholder if this child_name was |
|
357 |
// first seen via resolve_from_stream (jni_DefineClass or JVM_DefineClass); |
|
358 |
// the name of the class might not be known until the stream is actually |
|
359 |
// parsed. |
|
360 |
// Bugs 4643874, 4715493 |
|
361 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
362 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
46729 | 363 |
Dictionary* dictionary = loader_data->dictionary(); |
364 |
unsigned int d_hash = dictionary->compute_hash(child_name); |
|
365 |
int d_index = dictionary->hash_to_index(d_hash); |
|
366 |
unsigned int p_hash = placeholders()->compute_hash(child_name); |
|
1 | 367 |
int p_index = placeholders()->hash_to_index(p_hash); |
368 |
// can't throw error holding a lock |
|
369 |
bool child_already_loaded = false; |
|
370 |
bool throw_circularity_error = false; |
|
371 |
{ |
|
372 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
46729 | 373 |
Klass* childk = find_class(d_index, d_hash, child_name, dictionary); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
374 |
Klass* quicksuperk; |
1 | 375 |
// to support // loading: if child done loading, just return superclass |
376 |
// if class_name, & class_loader don't match: |
|
377 |
// if initial define, SD update will give LinkageError |
|
378 |
// if redefine: compare_class_versions will give HIERARCHY_CHANGED |
|
379 |
// so we don't throw an exception here. |
|
380 |
// see: nsk redefclass014 & java.lang.instrument Instrument032 |
|
381 |
if ((childk != NULL ) && (is_superclass) && |
|
33602 | 382 |
((quicksuperk = childk->super()) != NULL) && |
1 | 383 |
|
14488 | 384 |
((quicksuperk->name() == class_name) && |
385 |
(quicksuperk->class_loader() == class_loader()))) { |
|
1 | 386 |
return quicksuperk; |
387 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
388 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, loader_data); |
1 | 389 |
if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) { |
390 |
throw_circularity_error = true; |
|
391 |
} |
|
1890 | 392 |
} |
393 |
if (!throw_circularity_error) { |
|
40016 | 394 |
// Be careful not to exit resolve_super |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
395 |
PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, class_name, THREAD); |
1 | 396 |
} |
397 |
} |
|
398 |
if (throw_circularity_error) { |
|
399 |
ResourceMark rm(THREAD); |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
400 |
THROW_MSG_NULL(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string()); |
1 | 401 |
} |
402 |
||
403 |
// java.lang.Object should have been found above |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
404 |
assert(class_name != NULL, "null super class for resolving"); |
1 | 405 |
// Resolve the super class or interface, check results on return |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
406 |
Klass* superk = SystemDictionary::resolve_or_null(class_name, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
407 |
class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
408 |
protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
409 |
THREAD); |
1 | 410 |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
411 |
// Clean up of placeholders moved so that each classloadAction registrar self-cleans up |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
412 |
// It is no longer necessary to keep the placeholder table alive until update_dictionary |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
413 |
// or error. GC used to walk the placeholder table as strong roots. |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
414 |
// The instanceKlass is kept alive because the class loader is on the stack, |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
415 |
// which keeps the loader_data alive, as well as all instanceKlasses in |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
416 |
// the loader_data. parseClassFile adds the instanceKlass to loader_data. |
1 | 417 |
{ |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
418 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
419 |
placeholders()->find_and_remove(p_index, p_hash, child_name, loader_data, PlaceholderTable::LOAD_SUPER, THREAD); |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
420 |
SystemDictionary_lock->notify_all(); |
1 | 421 |
} |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
422 |
if (HAS_PENDING_EXCEPTION || superk == NULL) { |
1 | 423 |
// can null superk |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
424 |
superk = handle_resolution_exception(class_name, true, superk, THREAD); |
1 | 425 |
} |
426 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
427 |
return superk; |
1 | 428 |
} |
429 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
430 |
void SystemDictionary::validate_protection_domain(InstanceKlass* klass, |
1 | 431 |
Handle class_loader, |
432 |
Handle protection_domain, |
|
433 |
TRAPS) { |
|
434 |
if(!has_checkPackageAccess()) return; |
|
435 |
||
436 |
// Now we have to call back to java to check if the initating class has access |
|
437 |
JavaValue result(T_VOID); |
|
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
438 |
LogTarget(Debug, protectiondomain) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
439 |
if (lt.is_enabled()) { |
36381
b9ed6bef9364
8149064: TraceProtectionDomainVerification has been converted to Unified Logging.
mockner
parents:
35918
diff
changeset
|
440 |
ResourceMark rm; |
1 | 441 |
// Print out trace information |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
442 |
LogStream ls(lt); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
443 |
ls.print_cr("Checking package access"); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
444 |
ls.print("class loader: "); class_loader()->print_value_on(&ls); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
445 |
ls.print(" protection domain: "); protection_domain()->print_value_on(&ls); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
446 |
ls.print(" loading: "); klass->print_value_on(&ls); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46689
diff
changeset
|
447 |
ls.cr(); |
1 | 448 |
} |
449 |
||
46729 | 450 |
// This handle and the class_loader handle passed in keeps this class from |
451 |
// being unloaded through several GC points. |
|
452 |
// The class_loader handle passed in is the initiating loader. |
|
453 |
Handle mirror(THREAD, klass->java_mirror()); |
|
454 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
455 |
InstanceKlass* system_loader = SystemDictionary::ClassLoader_klass(); |
1 | 456 |
JavaCalls::call_special(&result, |
457 |
class_loader, |
|
458 |
system_loader, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
459 |
vmSymbols::checkPackageAccess_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
460 |
vmSymbols::class_protectiondomain_signature(), |
46729 | 461 |
mirror, |
1 | 462 |
protection_domain, |
463 |
THREAD); |
|
464 |
||
36381
b9ed6bef9364
8149064: TraceProtectionDomainVerification has been converted to Unified Logging.
mockner
parents:
35918
diff
changeset
|
465 |
if (HAS_PENDING_EXCEPTION) { |
b9ed6bef9364
8149064: TraceProtectionDomainVerification has been converted to Unified Logging.
mockner
parents:
35918
diff
changeset
|
466 |
log_debug(protectiondomain)("DENIED !!!!!!!!!!!!!!!!!!!!!"); |
b9ed6bef9364
8149064: TraceProtectionDomainVerification has been converted to Unified Logging.
mockner
parents:
35918
diff
changeset
|
467 |
} else { |
b9ed6bef9364
8149064: TraceProtectionDomainVerification has been converted to Unified Logging.
mockner
parents:
35918
diff
changeset
|
468 |
log_debug(protectiondomain)("granted"); |
1 | 469 |
} |
470 |
||
471 |
if (HAS_PENDING_EXCEPTION) return; |
|
472 |
||
473 |
// If no exception has been thrown, we have validated the protection domain |
|
474 |
// Insert the protection domain of the initiating class into the set. |
|
475 |
{ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
476 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
46729 | 477 |
Dictionary* dictionary = loader_data->dictionary(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
478 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
479 |
Symbol* kn = klass->name(); |
46729 | 480 |
unsigned int d_hash = dictionary->compute_hash(kn); |
481 |
int d_index = dictionary->hash_to_index(d_hash); |
|
1 | 482 |
|
483 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
46729 | 484 |
dictionary->add_protection_domain(d_index, d_hash, klass, |
485 |
protection_domain, THREAD); |
|
1 | 486 |
} |
487 |
} |
|
488 |
||
489 |
// We only get here if this thread finds that another thread |
|
490 |
// has already claimed the placeholder token for the current operation, |
|
491 |
// but that other thread either never owned or gave up the |
|
492 |
// object lock |
|
493 |
// Waits on SystemDictionary_lock to indicate placeholder table updated |
|
494 |
// On return, caller must recheck placeholder table state |
|
495 |
// |
|
496 |
// We only get here if |
|
497 |
// 1) custom classLoader, i.e. not bootstrap classloader |
|
498 |
// 2) UnsyncloadClass not set |
|
499 |
// 3) custom classLoader has broken the class loader objectLock |
|
500 |
// so another thread got here in parallel |
|
501 |
// |
|
502 |
// lockObject must be held. |
|
503 |
// Complicated dance due to lock ordering: |
|
504 |
// Must first release the classloader object lock to |
|
505 |
// allow initial definer to complete the class definition |
|
506 |
// and to avoid deadlock |
|
507 |
// Reclaim classloader lock object with same original recursion count |
|
508 |
// Must release SystemDictionary_lock after notify, since |
|
509 |
// class loader lock must be claimed before SystemDictionary_lock |
|
510 |
// to prevent deadlocks |
|
511 |
// |
|
512 |
// The notify allows applications that did an untimed wait() on |
|
513 |
// the classloader object lock to not hang. |
|
514 |
void SystemDictionary::double_lock_wait(Handle lockObject, TRAPS) { |
|
515 |
assert_lock_strong(SystemDictionary_lock); |
|
516 |
||
517 |
bool calledholdinglock |
|
518 |
= ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, lockObject); |
|
519 |
assert(calledholdinglock,"must hold lock for notify"); |
|
1890 | 520 |
assert((!(lockObject() == _system_loader_lock_obj) && !is_parallelCapable(lockObject)), "unexpected double_lock_wait"); |
1 | 521 |
ObjectSynchronizer::notifyall(lockObject, THREAD); |
522 |
intptr_t recursions = ObjectSynchronizer::complete_exit(lockObject, THREAD); |
|
523 |
SystemDictionary_lock->wait(); |
|
524 |
SystemDictionary_lock->unlock(); |
|
525 |
ObjectSynchronizer::reenter(lockObject, recursions, THREAD); |
|
526 |
SystemDictionary_lock->lock(); |
|
527 |
} |
|
528 |
||
529 |
// If the class in is in the placeholder table, class loading is in progress |
|
530 |
// For cases where the application changes threads to load classes, it |
|
531 |
// is critical to ClassCircularity detection that we try loading |
|
532 |
// the superclass on the same thread internally, so we do parallel |
|
533 |
// super class loading here. |
|
534 |
// This also is critical in cases where the original thread gets stalled |
|
535 |
// even in non-circularity situations. |
|
536 |
// Note: must call resolve_super_or_fail even if null super - |
|
1890 | 537 |
// to force placeholder entry creation for this class for circularity detection |
1 | 538 |
// Caller must check for pending exception |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
539 |
// Returns non-null Klass* if other thread has completed load |
1 | 540 |
// and we are done, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
541 |
// If return null Klass* and no pending exception, the caller must load the class |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
542 |
InstanceKlass* SystemDictionary::handle_parallel_super_load( |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
543 |
Symbol* name, Symbol* superclassname, Handle class_loader, |
1 | 544 |
Handle protection_domain, Handle lockObject, TRAPS) { |
545 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
546 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
46729 | 547 |
Dictionary* dictionary = loader_data->dictionary(); |
548 |
unsigned int d_hash = dictionary->compute_hash(name); |
|
549 |
int d_index = dictionary->hash_to_index(d_hash); |
|
550 |
unsigned int p_hash = placeholders()->compute_hash(name); |
|
1 | 551 |
int p_index = placeholders()->hash_to_index(p_hash); |
552 |
||
553 |
// superk is not used, resolve_super called for circularity check only |
|
554 |
// This code is reached in two situations. One if this thread |
|
555 |
// is loading the same class twice (e.g. ClassCircularity, or |
|
556 |
// java.lang.instrument). |
|
557 |
// The second is if another thread started the resolve_super first |
|
558 |
// and has not yet finished. |
|
559 |
// In both cases the original caller will clean up the placeholder |
|
560 |
// entry on error. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
561 |
Klass* superk = SystemDictionary::resolve_super_or_fail(name, |
1 | 562 |
superclassname, |
563 |
class_loader, |
|
564 |
protection_domain, |
|
565 |
true, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
566 |
CHECK_NULL); |
1 | 567 |
|
1890 | 568 |
// parallelCapable class loaders do NOT wait for parallel superclass loads to complete |
569 |
// Serial class loaders and bootstrap classloader do wait for superclass loads |
|
570 |
if (!class_loader.is_null() && is_parallelCapable(class_loader)) { |
|
1 | 571 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
572 |
// Check if classloading completed while we were loading superclass or waiting |
|
46729 | 573 |
return find_class(d_index, d_hash, name, dictionary); |
1 | 574 |
} |
575 |
||
576 |
// must loop to both handle other placeholder updates |
|
577 |
// and spurious notifications |
|
578 |
bool super_load_in_progress = true; |
|
579 |
PlaceholderEntry* placeholder; |
|
580 |
while (super_load_in_progress) { |
|
581 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
582 |
// Check if classloading completed while we were loading superclass or waiting |
|
46729 | 583 |
InstanceKlass* check = find_class(d_index, d_hash, name, dictionary); |
1 | 584 |
if (check != NULL) { |
585 |
// Klass is already loaded, so just return it |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
586 |
return check; |
1 | 587 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
588 |
placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 589 |
if (placeholder && placeholder->super_load_in_progress() ){ |
590 |
// Before UnsyncloadClass: |
|
591 |
// We only get here if the application has released the |
|
592 |
// classloader lock when another thread was in the middle of loading a |
|
593 |
// superclass/superinterface for this class, and now |
|
594 |
// this thread is also trying to load this class. |
|
595 |
// To minimize surprises, the first thread that started to |
|
596 |
// load a class should be the one to complete the loading |
|
597 |
// with the classfile it initially expected. |
|
598 |
// This logic has the current thread wait once it has done |
|
599 |
// all the superclass/superinterface loading it can, until |
|
600 |
// the original thread completes the class loading or fails |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
601 |
// If it completes we will use the resulting InstanceKlass |
1 | 602 |
// which we will find below in the systemDictionary. |
603 |
// We also get here for parallel bootstrap classloader |
|
604 |
if (class_loader.is_null()) { |
|
605 |
SystemDictionary_lock->wait(); |
|
606 |
} else { |
|
607 |
double_lock_wait(lockObject, THREAD); |
|
608 |
} |
|
609 |
} else { |
|
610 |
// If not in SD and not in PH, other thread's load must have failed |
|
611 |
super_load_in_progress = false; |
|
612 |
} |
|
613 |
} |
|
614 |
} |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
615 |
return NULL; |
1 | 616 |
} |
617 |
||
34666 | 618 |
static void post_class_load_event(const Ticks& start_time, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
619 |
InstanceKlass* k, |
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
620 |
const ClassLoaderData* init_cld) { |
34666 | 621 |
#if INCLUDE_TRACE |
622 |
EventClassLoad event(UNTIMED); |
|
623 |
if (event.should_commit()) { |
|
624 |
event.set_starttime(start_time); |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
625 |
event.set_loadedClass(k); |
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
626 |
event.set_definingClassLoader(k->class_loader_data()); |
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
627 |
event.set_initiatingClassLoader(init_cld); |
34666 | 628 |
event.commit(); |
629 |
} |
|
630 |
#endif // INCLUDE_TRACE |
|
631 |
} |
|
1 | 632 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
633 |
static void class_define_event(InstanceKlass* k, |
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
634 |
const ClassLoaderData* def_cld) { |
40002
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
635 |
#if INCLUDE_TRACE |
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
636 |
EventClassDefine event; |
40002
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
637 |
if (event.should_commit()) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
638 |
event.set_definedClass(k); |
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
639 |
event.set_definingClassLoader(def_cld); |
40002
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
640 |
event.commit(); |
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
641 |
} |
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
642 |
#endif // INCLUDE_TRACE |
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
643 |
} |
156b2dbb0b54
8038332: The trace event vm/class/load is not always being sent
mockner
parents:
39986
diff
changeset
|
644 |
|
40016 | 645 |
// Be careful when modifying this code: once you have run |
646 |
// placeholders()->find_and_add(PlaceholderTable::LOAD_INSTANCE), |
|
647 |
// you need to find_and_remove it before returning. |
|
648 |
// So be careful to not exit with a CHECK_ macro betweeen these calls. |
|
18025 | 649 |
Klass* SystemDictionary::resolve_instance_class_or_null(Symbol* name, |
650 |
Handle class_loader, |
|
651 |
Handle protection_domain, |
|
652 |
TRAPS) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
653 |
assert(name != NULL && !FieldType::is_array(name) && |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
654 |
!FieldType::is_obj(name), "invalid class name"); |
1 | 655 |
|
21767
41eaa9a17059
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
21103
diff
changeset
|
656 |
Ticks class_load_start_time = Ticks::now(); |
18025 | 657 |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
658 |
HandleMark hm(THREAD); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
659 |
|
1 | 660 |
// Fix for 4474172; see evaluation for more details |
661 |
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); |
|
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
662 |
ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL); |
46729 | 663 |
Dictionary* dictionary = loader_data->dictionary(); |
1 | 664 |
|
665 |
// Do lookup to see if class already exist and the protection domain |
|
666 |
// has the right access |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
667 |
// This call uses find which checks protection domain already matches |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
668 |
// All subsequent calls use find_class, and set has_loaded_class so that |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
669 |
// before we return a result we call out to java to check for valid protection domain |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
670 |
// to allow returning the Klass* and add it to the pd_set if it is valid |
46729 | 671 |
unsigned int d_hash = dictionary->compute_hash(name); |
672 |
int d_index = dictionary->hash_to_index(d_hash); |
|
673 |
Klass* probe = dictionary->find(d_index, d_hash, name, protection_domain); |
|
1 | 674 |
if (probe != NULL) return probe; |
675 |
||
676 |
||
677 |
// Non-bootstrap class loaders will call out to class loader and |
|
678 |
// define via jvm/jni_DefineClass which will acquire the |
|
679 |
// class loader object lock to protect against multiple threads |
|
680 |
// defining the class in parallel by accident. |
|
681 |
// This lock must be acquired here so the waiter will find |
|
682 |
// any successful result in the SystemDictionary and not attempt |
|
683 |
// the define |
|
1890 | 684 |
// ParallelCapable Classloaders and the bootstrap classloader, |
1 | 685 |
// or all classloaders with UnsyncloadClass do not acquire lock here |
686 |
bool DoObjectLock = true; |
|
1890 | 687 |
if (is_parallelCapable(class_loader)) { |
1 | 688 |
DoObjectLock = false; |
689 |
} |
|
690 |
||
46729 | 691 |
unsigned int p_hash = placeholders()->compute_hash(name); |
1 | 692 |
int p_index = placeholders()->hash_to_index(p_hash); |
693 |
||
694 |
// Class is not in SystemDictionary so we have to do loading. |
|
695 |
// Make sure we are synchronized on the class loader before we proceed |
|
696 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
|
697 |
check_loader_lock_contention(lockObject, THREAD); |
|
698 |
ObjectLocker ol(lockObject, THREAD, DoObjectLock); |
|
699 |
||
700 |
// Check again (after locking) if class already exist in SystemDictionary |
|
701 |
bool class_has_been_loaded = false; |
|
702 |
bool super_load_in_progress = false; |
|
703 |
bool havesupername = false; |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
704 |
InstanceKlass* k = NULL; |
1 | 705 |
PlaceholderEntry* placeholder; |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
706 |
Symbol* superclassname = NULL; |
1 | 707 |
|
708 |
{ |
|
709 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
46729 | 710 |
InstanceKlass* check = find_class(d_index, d_hash, name, dictionary); |
1 | 711 |
if (check != NULL) { |
712 |
// Klass is already loaded, so just return it |
|
713 |
class_has_been_loaded = true; |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
714 |
k = check; |
1 | 715 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
716 |
placeholder = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 717 |
if (placeholder && placeholder->super_load_in_progress()) { |
718 |
super_load_in_progress = true; |
|
719 |
if (placeholder->havesupername() == true) { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
720 |
superclassname = placeholder->supername(); |
1 | 721 |
havesupername = true; |
722 |
} |
|
723 |
} |
|
724 |
} |
|
725 |
} |
|
726 |
||
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
727 |
// If the class is in the placeholder table, class loading is in progress |
1 | 728 |
if (super_load_in_progress && havesupername==true) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
729 |
k = handle_parallel_super_load(name, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
730 |
superclassname, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
731 |
class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
732 |
protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
733 |
lockObject, THREAD); |
1 | 734 |
if (HAS_PENDING_EXCEPTION) { |
735 |
return NULL; |
|
736 |
} |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
737 |
if (k != NULL) { |
1 | 738 |
class_has_been_loaded = true; |
739 |
} |
|
740 |
} |
|
741 |
||
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
742 |
bool throw_circularity_error = false; |
1 | 743 |
if (!class_has_been_loaded) { |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
744 |
bool load_instance_added = false; |
1 | 745 |
|
746 |
// add placeholder entry to record loading instance class |
|
747 |
// Five cases: |
|
748 |
// All cases need to prevent modifying bootclasssearchpath |
|
749 |
// in parallel with a classload of same classname |
|
1890 | 750 |
// Redefineclasses uses existence of the placeholder for the duration |
751 |
// of the class load to prevent concurrent redefinition of not completely |
|
752 |
// defined classes. |
|
1 | 753 |
// case 1. traditional classloaders that rely on the classloader object lock |
754 |
// - no other need for LOAD_INSTANCE |
|
755 |
// case 2. traditional classloaders that break the classloader object lock |
|
756 |
// as a deadlock workaround. Detection of this case requires that |
|
757 |
// this check is done while holding the classloader object lock, |
|
758 |
// and that lock is still held when calling classloader's loadClass. |
|
759 |
// For these classloaders, we ensure that the first requestor |
|
760 |
// completes the load and other requestors wait for completion. |
|
761 |
// case 3. UnsyncloadClass - don't use objectLocker |
|
762 |
// With this flag, we allow parallel classloading of a |
|
763 |
// class/classloader pair |
|
764 |
// case4. Bootstrap classloader - don't own objectLocker |
|
765 |
// This classloader supports parallelism at the classloader level, |
|
766 |
// but only allows a single load of a class/classloader pair. |
|
767 |
// No performance benefit and no deadlock issues. |
|
1890 | 768 |
// case 5. parallelCapable user level classloaders - without objectLocker |
769 |
// Allow parallel classloading of a class/classloader pair |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
770 |
|
1 | 771 |
{ |
772 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
1890 | 773 |
if (class_loader.is_null() || !is_parallelCapable(class_loader)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
774 |
PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 775 |
if (oldprobe) { |
776 |
// only need check_seen_thread once, not on each loop |
|
777 |
// 6341374 java/lang/Instrument with -Xcomp |
|
778 |
if (oldprobe->check_seen_thread(THREAD, PlaceholderTable::LOAD_INSTANCE)) { |
|
779 |
throw_circularity_error = true; |
|
780 |
} else { |
|
781 |
// case 1: traditional: should never see load_in_progress. |
|
782 |
while (!class_has_been_loaded && oldprobe && oldprobe->instance_load_in_progress()) { |
|
783 |
||
784 |
// case 4: bootstrap classloader: prevent futile classloading, |
|
785 |
// wait on first requestor |
|
786 |
if (class_loader.is_null()) { |
|
787 |
SystemDictionary_lock->wait(); |
|
788 |
} else { |
|
789 |
// case 2: traditional with broken classloader lock. wait on first |
|
790 |
// requestor. |
|
791 |
double_lock_wait(lockObject, THREAD); |
|
792 |
} |
|
793 |
// Check if classloading completed while we were waiting |
|
46729 | 794 |
InstanceKlass* check = find_class(d_index, d_hash, name, dictionary); |
1 | 795 |
if (check != NULL) { |
796 |
// Klass is already loaded, so just return it |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
797 |
k = check; |
1 | 798 |
class_has_been_loaded = true; |
799 |
} |
|
800 |
// check if other thread failed to load and cleaned up |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
801 |
oldprobe = placeholders()->get_entry(p_index, p_hash, name, loader_data); |
1 | 802 |
} |
803 |
} |
|
804 |
} |
|
805 |
} |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
806 |
// All cases: add LOAD_INSTANCE holding SystemDictionary_lock |
1890 | 807 |
// case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try |
1 | 808 |
// LOAD_INSTANCE in parallel |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
809 |
|
1890 | 810 |
if (!throw_circularity_error && !class_has_been_loaded) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
811 |
PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, NULL, THREAD); |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
812 |
load_instance_added = true; |
1 | 813 |
// For class loaders that do not acquire the classloader object lock, |
814 |
// if they did not catch another thread holding LOAD_INSTANCE, |
|
815 |
// need a check analogous to the acquire ObjectLocker/find_class |
|
816 |
// i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL |
|
817 |
// one final check if the load has already completed |
|
1890 | 818 |
// class loaders holding the ObjectLock shouldn't find the class here |
46729 | 819 |
InstanceKlass* check = find_class(d_index, d_hash, name, dictionary); |
1 | 820 |
if (check != NULL) { |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
821 |
// Klass is already loaded, so return it after checking/adding protection domain |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
822 |
k = check; |
1 | 823 |
class_has_been_loaded = true; |
824 |
} |
|
825 |
} |
|
826 |
} |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
827 |
|
1 | 828 |
// must throw error outside of owning lock |
829 |
if (throw_circularity_error) { |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
830 |
assert(!HAS_PENDING_EXCEPTION && load_instance_added == false,"circularity error cleanup"); |
1 | 831 |
ResourceMark rm(THREAD); |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
832 |
THROW_MSG_NULL(vmSymbols::java_lang_ClassCircularityError(), name->as_C_string()); |
1 | 833 |
} |
834 |
||
835 |
if (!class_has_been_loaded) { |
|
836 |
||
837 |
// Do actual loading |
|
838 |
k = load_instance_class(name, class_loader, THREAD); |
|
839 |
||
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
840 |
// For UnsyncloadClass only |
1 | 841 |
// If they got a linkageError, check if a parallel class load succeeded. |
842 |
// If it did, then for bytecode resolution the specification requires |
|
843 |
// that we return the same result we did for the other thread, i.e. the |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
844 |
// successfully loaded InstanceKlass |
1 | 845 |
// Should not get here for classloaders that support parallelism |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
846 |
// with the new cleaner mechanism, even with AllowParallelDefineClass |
1890 | 847 |
// Bootstrap goes through here to allow for an extra guarantee check |
1 | 848 |
if (UnsyncloadClass || (class_loader.is_null())) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
849 |
if (k == NULL && HAS_PENDING_EXCEPTION |
4571 | 850 |
&& PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { |
1 | 851 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
46729 | 852 |
InstanceKlass* check = find_class(d_index, d_hash, name, dictionary); |
1 | 853 |
if (check != NULL) { |
854 |
// Klass is already loaded, so just use it |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
855 |
k = check; |
1 | 856 |
CLEAR_PENDING_EXCEPTION; |
857 |
guarantee((!class_loader.is_null()), "dup definition for bootstrap loader?"); |
|
858 |
} |
|
859 |
} |
|
860 |
} |
|
861 |
||
862 |
// If everything was OK (no exceptions, no null return value), and |
|
863 |
// class_loader is NOT the defining loader, do a little more bookkeeping. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
864 |
if (!HAS_PENDING_EXCEPTION && k != NULL && |
1 | 865 |
k->class_loader() != class_loader()) { |
866 |
||
867 |
check_constraints(d_index, d_hash, k, class_loader, false, THREAD); |
|
868 |
||
869 |
// Need to check for a PENDING_EXCEPTION again; check_constraints |
|
870 |
// can throw and doesn't use the CHECK macro. |
|
871 |
if (!HAS_PENDING_EXCEPTION) { |
|
872 |
{ // Grabbing the Compile_lock prevents systemDictionary updates |
|
873 |
// during compilations. |
|
874 |
MutexLocker mu(Compile_lock, THREAD); |
|
875 |
update_dictionary(d_index, d_hash, p_index, p_hash, |
|
18025 | 876 |
k, class_loader, THREAD); |
1 | 877 |
} |
18025 | 878 |
|
1 | 879 |
if (JvmtiExport::should_post_class_load()) { |
880 |
Thread *thread = THREAD; |
|
881 |
assert(thread->is_Java_thread(), "thread->is_Java_thread()"); |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
882 |
JvmtiExport::post_class_load((JavaThread *) thread, k); |
1 | 883 |
} |
884 |
} |
|
885 |
} |
|
46729 | 886 |
} // load_instance_class |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
887 |
|
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
888 |
if (load_instance_added == true) { |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
889 |
// clean up placeholder entries for LOAD_INSTANCE success or error |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
890 |
// This brackets the SystemDictionary updates for both defining |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
891 |
// and initiating loaders |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
892 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
18025 | 893 |
placeholders()->find_and_remove(p_index, p_hash, name, loader_data, PlaceholderTable::LOAD_INSTANCE, THREAD); |
894 |
SystemDictionary_lock->notify_all(); |
|
1 | 895 |
} |
896 |
} |
|
897 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
898 |
if (HAS_PENDING_EXCEPTION || k == NULL) { |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
899 |
return NULL; |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
900 |
} |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
901 |
|
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
902 |
post_class_load_event(class_load_start_time, k, loader_data); |
18025 | 903 |
|
1 | 904 |
#ifdef ASSERT |
905 |
{ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
906 |
ClassLoaderData* loader_data = k->class_loader_data(); |
1 | 907 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
908 |
Klass* kk = find_class(name, loader_data); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
909 |
assert(kk == k, "should be present in dictionary"); |
1 | 910 |
} |
911 |
#endif |
|
912 |
||
913 |
// return if the protection domain in NULL |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
914 |
if (protection_domain() == NULL) return k; |
1 | 915 |
|
916 |
// Check the protection domain has the right access |
|
917 |
{ |
|
918 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
46729 | 919 |
if (dictionary->is_valid_protection_domain(d_index, d_hash, name, |
920 |
protection_domain)) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
921 |
return k; |
1 | 922 |
} |
923 |
} |
|
924 |
||
925 |
// Verify protection domain. If it fails an exception is thrown |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
926 |
validate_protection_domain(k, class_loader, protection_domain, CHECK_NULL); |
1 | 927 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
928 |
return k; |
1 | 929 |
} |
930 |
||
931 |
||
932 |
// This routine does not lock the system dictionary. |
|
933 |
// |
|
934 |
// Since readers don't hold a lock, we must make sure that system |
|
935 |
// dictionary entries are only removed at a safepoint (when only one |
|
936 |
// thread is running), and are added to in a safe way (all links must |
|
937 |
// be updated in an MT-safe manner). |
|
938 |
// |
|
939 |
// Callers should be aware that an entry could be added just after |
|
940 |
// _dictionary->bucket(index) is read here, so the caller will not see |
|
941 |
// the new entry. |
|
942 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
943 |
Klass* SystemDictionary::find(Symbol* class_name, |
15847
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
944 |
Handle class_loader, |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
945 |
Handle protection_domain, |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
946 |
TRAPS) { |
1 | 947 |
|
2020
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
948 |
// The result of this call should be consistent with the result |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
949 |
// of the call to resolve_instance_class_or_null(). |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
950 |
// See evaluation 6790209 and 4474172 for more details. |
68d27ca96f33
6790209: server VM fails with assert(will_link,"_new: typeflow responsibility")
kvn
parents:
1550
diff
changeset
|
951 |
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); |
15847
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
952 |
ClassLoaderData* loader_data = ClassLoaderData::class_loader_data_or_null(class_loader()); |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
953 |
|
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
954 |
if (loader_data == NULL) { |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
955 |
// If the ClassLoaderData has not been setup, |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
956 |
// then the class loader has no entries in the dictionary. |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
957 |
return NULL; |
f9ce2cd20dee
8008549: NPG: SystemDictionary::find(...) unnecessarily keeps class loaders alive
stefank
parents:
15432
diff
changeset
|
958 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
959 |
|
46729 | 960 |
Dictionary* dictionary = loader_data->dictionary(); |
961 |
unsigned int d_hash = dictionary->compute_hash(class_name); |
|
962 |
int d_index = dictionary->hash_to_index(d_hash); |
|
963 |
return dictionary->find(d_index, d_hash, class_name, |
|
964 |
protection_domain); |
|
1 | 965 |
} |
966 |
||
967 |
||
968 |
// Look for a loaded instance or array klass by name. Do not do any loading. |
|
969 |
// return NULL in case of error. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
970 |
Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name, |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
971 |
Handle class_loader, |
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
972 |
Handle protection_domain, |
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
973 |
TRAPS) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
974 |
Klass* k = NULL; |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
975 |
assert(class_name != NULL, "class name must be non NULL"); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
976 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
977 |
if (FieldType::is_array(class_name)) { |
1 | 978 |
// The name refers to an array. Parse the name. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
979 |
// dimension and object_key in FieldArrayInfo are assigned as a |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
980 |
// side-effect of this call |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
981 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
982 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
1 | 983 |
if (t != T_OBJECT) { |
984 |
k = Universe::typeArrayKlassObj(t); |
|
985 |
} else { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
986 |
k = SystemDictionary::find(fd.object_key(), class_loader, protection_domain, THREAD); |
1 | 987 |
} |
988 |
if (k != NULL) { |
|
14488 | 989 |
k = k->array_klass_or_null(fd.dimension()); |
1 | 990 |
} |
991 |
} else { |
|
992 |
k = find(class_name, class_loader, protection_domain, THREAD); |
|
993 |
} |
|
994 |
return k; |
|
995 |
} |
|
996 |
||
997 |
// Note: this method is much like resolve_from_stream, but |
|
40016 | 998 |
// does not publish the classes via the SystemDictionary. |
999 |
// Handles unsafe_DefineAnonymousClass and redefineclasses |
|
1000 |
// RedefinedClasses do not add to the class hierarchy |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1001 |
InstanceKlass* SystemDictionary::parse_stream(Symbol* class_name, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1002 |
Handle class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1003 |
Handle protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1004 |
ClassFileStream* st, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1005 |
const InstanceKlass* host_klass, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1006 |
GrowableArray<Handle>* cp_patches, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1007 |
TRAPS) { |
1 | 1008 |
|
21767
41eaa9a17059
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
21103
diff
changeset
|
1009 |
Ticks class_load_start_time = Ticks::now(); |
18025 | 1010 |
|
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1011 |
ClassLoaderData* loader_data; |
34666 | 1012 |
if (host_klass != NULL) { |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1013 |
// Create a new CLD for anonymous class, that uses the same class loader |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1014 |
// as the host_klass |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1015 |
guarantee(host_klass->class_loader() == class_loader(), "should be the same"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1016 |
guarantee(!DumpSharedSpaces, "must not create anonymous classes when dumping"); |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1017 |
loader_data = ClassLoaderData::anonymous_class_loader_data(class_loader(), CHECK_NULL); |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1018 |
} else { |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1019 |
loader_data = ClassLoaderData::class_loader_data(class_loader()); |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1020 |
} |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1021 |
|
34666 | 1022 |
assert(st != NULL, "invariant"); |
1023 |
assert(st->need_verify(), "invariant"); |
|
1024 |
||
1025 |
// Parse stream and create a klass. |
|
1026 |
// Note that we do this even though this klass might |
|
1 | 1027 |
// already be present in the SystemDictionary, otherwise we would not |
1028 |
// throw potential ClassFormatErrors. |
|
1029 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1030 |
InstanceKlass* k = KlassFactory::create_from_stream(st, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1031 |
class_name, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1032 |
loader_data, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1033 |
protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1034 |
host_klass, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1035 |
cp_patches, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1036 |
CHECK_NULL); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1037 |
|
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1038 |
if (host_klass != NULL && k != NULL) { |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1039 |
// If it's anonymous, initialize it now, since nobody else will. |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1040 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1041 |
{ |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1042 |
MutexLocker mu_r(Compile_lock, THREAD); |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1043 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1044 |
// Add to class hierarchy, initialize vtables, and do possible |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1045 |
// deoptimizations. |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1046 |
add_to_hierarchy(k, CHECK_NULL); // No exception, but can block |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1047 |
|
46729 | 1048 |
// But, do not add to dictionary. |
22231
1cca24bb3125
8029383: assert(counter_changed) failed: failed dependencies, but counter didn't change
roland
parents:
21767
diff
changeset
|
1049 |
|
1cca24bb3125
8029383: assert(counter_changed) failed: failed dependencies, but counter didn't change
roland
parents:
21767
diff
changeset
|
1050 |
// compiled code dependencies need to be validated anyway |
1cca24bb3125
8029383: assert(counter_changed) failed: failed dependencies, but counter didn't change
roland
parents:
21767
diff
changeset
|
1051 |
notice_modification(); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1052 |
} |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1053 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1054 |
// Rewrite and patch constant pool here. |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1055 |
k->link_class(CHECK_NULL); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1056 |
if (cp_patches != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1057 |
k->constants()->patch_resolved_references(cp_patches); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1058 |
} |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1059 |
k->eager_initialize(CHECK_NULL); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1060 |
|
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1061 |
// notify jvmti |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1062 |
if (JvmtiExport::should_post_class_load()) { |
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1063 |
assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1064 |
JvmtiExport::post_class_load((JavaThread *) THREAD, k); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1065 |
} |
18025 | 1066 |
|
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
1067 |
post_class_load_event(class_load_start_time, k, loader_data); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1068 |
} |
34666 | 1069 |
assert(host_klass != NULL || NULL == cp_patches, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1070 |
"cp_patches only found with host_klass"); |
1550
be2fc37a817f
6653858: dynamic languages need to be able to load anonymous classes
jrose
parents:
670
diff
changeset
|
1071 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1072 |
return k; |
1 | 1073 |
} |
1074 |
||
1075 |
// Add a klass to the system from a stream (called by jni_DefineClass and |
|
1076 |
// JVM_DefineClass). |
|
1077 |
// Note: class_name can be NULL. In that case we do not know the name of |
|
1078 |
// the class until we have parsed the stream. |
|
1079 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1080 |
InstanceKlass* SystemDictionary::resolve_from_stream(Symbol* class_name, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1081 |
Handle class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1082 |
Handle protection_domain, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1083 |
ClassFileStream* st, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1084 |
TRAPS) { |
1 | 1085 |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
1086 |
HandleMark hm(THREAD); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
1087 |
|
1890 | 1088 |
// Classloaders that support parallelism, e.g. bootstrap classloader, |
1089 |
// or all classloaders with UnsyncloadClass do not acquire lock here |
|
1090 |
bool DoObjectLock = true; |
|
1091 |
if (is_parallelCapable(class_loader)) { |
|
1092 |
DoObjectLock = false; |
|
1093 |
} |
|
1094 |
||
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
1095 |
ClassLoaderData* loader_data = register_loader(class_loader, CHECK_NULL); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1096 |
|
1890 | 1097 |
// Make sure we are synchronized on the class loader before we proceed |
1 | 1098 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
1099 |
check_loader_lock_contention(lockObject, THREAD); |
|
1890 | 1100 |
ObjectLocker ol(lockObject, THREAD, DoObjectLock); |
1 | 1101 |
|
34666 | 1102 |
assert(st != NULL, "invariant"); |
1 | 1103 |
|
34666 | 1104 |
// Parse the stream and create a klass. |
1105 |
// Note that we do this even though this klass might |
|
1 | 1106 |
// already be present in the SystemDictionary, otherwise we would not |
1107 |
// throw potential ClassFormatErrors. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1108 |
InstanceKlass* k = NULL; |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1109 |
|
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1110 |
#if INCLUDE_CDS |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1111 |
k = SystemDictionaryShared::lookup_from_stream(class_name, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1112 |
class_loader, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1113 |
protection_domain, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1114 |
st, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1115 |
CHECK_NULL); |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1116 |
#endif |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1117 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1118 |
if (k == NULL) { |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1119 |
if (st->buffer() == NULL) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1120 |
return NULL; |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1121 |
} |
34666 | 1122 |
k = KlassFactory::create_from_stream(st, |
1123 |
class_name, |
|
1124 |
loader_data, |
|
1125 |
protection_domain, |
|
1126 |
NULL, // host_klass |
|
1127 |
NULL, // cp_patches |
|
40016 | 1128 |
CHECK_NULL); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1129 |
} |
1 | 1130 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1131 |
assert(k != NULL, "no klass created"); |
40016 | 1132 |
Symbol* h_name = k->name(); |
1133 |
assert(class_name == NULL || class_name == h_name, "name mismatch"); |
|
1 | 1134 |
|
40016 | 1135 |
// Add class just loaded |
1136 |
// If a class loader supports parallel classloading handle parallel define requests |
|
1137 |
// find_or_define_instance_class may return a different InstanceKlass |
|
1138 |
if (is_parallelCapable(class_loader)) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1139 |
InstanceKlass* defined_k = find_or_define_instance_class(h_name, class_loader, k, THREAD); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1140 |
if (!HAS_PENDING_EXCEPTION && defined_k != k) { |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1141 |
// If a parallel capable class loader already defined this class, register 'k' for cleanup. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1142 |
assert(defined_k != NULL, "Should have a klass if there's no exception"); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1143 |
loader_data->add_to_deallocate_list(k); |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1144 |
k = defined_k; |
42650 | 1145 |
} |
40016 | 1146 |
} else { |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1147 |
define_instance_class(k, THREAD); |
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1148 |
} |
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1149 |
|
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1150 |
// If defining the class throws an exception register 'k' for cleanup. |
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1151 |
if (HAS_PENDING_EXCEPTION) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1152 |
assert(k != NULL, "Must have an instance klass here!"); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1153 |
loader_data->add_to_deallocate_list(k); |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1154 |
return NULL; |
1 | 1155 |
} |
1156 |
||
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
1157 |
// Make sure we have an entry in the SystemDictionary on success |
1 | 1158 |
debug_only( { |
40016 | 1159 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
1 | 1160 |
|
40016 | 1161 |
Klass* check = find_class(h_name, k->class_loader_data()); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1162 |
assert(check == k, "should be present in the dictionary"); |
1 | 1163 |
} ); |
1164 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1165 |
return k; |
1 | 1166 |
} |
1167 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1168 |
#if INCLUDE_CDS |
13195 | 1169 |
void SystemDictionary::set_shared_dictionary(HashtableBucket<mtClass>* t, int length, |
1 | 1170 |
int number_of_entries) { |
46729 | 1171 |
assert(length == _shared_dictionary_size * sizeof(HashtableBucket<mtClass>), |
1 | 1172 |
"bad shared dictionary size."); |
46729 | 1173 |
_shared_dictionary = new Dictionary(ClassLoaderData::the_null_class_loader_data(), |
1174 |
_shared_dictionary_size, t, number_of_entries); |
|
1 | 1175 |
} |
1176 |
||
1177 |
||
1178 |
// If there is a shared dictionary, then find the entry for the |
|
1179 |
// given shared system class, if any. |
|
1180 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1181 |
InstanceKlass* SystemDictionary::find_shared_class(Symbol* class_name) { |
1 | 1182 |
if (shared_dictionary() != NULL) { |
46729 | 1183 |
unsigned int d_hash = shared_dictionary()->compute_hash(class_name); |
11628
13155c0c00b4
7114376: Make system dictionary hashtable bucket array size configurable
acorn
parents:
11480
diff
changeset
|
1184 |
int d_index = shared_dictionary()->hash_to_index(d_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1185 |
|
1 | 1186 |
return shared_dictionary()->find_shared_class(d_index, d_hash, class_name); |
1187 |
} else { |
|
1188 |
return NULL; |
|
1189 |
} |
|
1190 |
} |
|
1191 |
||
1192 |
||
1193 |
// Load a class from the shared spaces (found through the shared system |
|
1194 |
// dictionary). Force the superclass and all interfaces to be loaded. |
|
1195 |
// Update the class definition to include sibling classes and no |
|
1196 |
// subclasses (yet). [Classes in the shared space are not part of the |
|
1197 |
// object hierarchy until loaded.] |
|
1198 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1199 |
InstanceKlass* SystemDictionary::load_shared_class( |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1200 |
Symbol* class_name, Handle class_loader, TRAPS) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1201 |
InstanceKlass* ik = find_shared_class(class_name); |
41182 | 1202 |
// Make sure we only return the boot class for the NULL classloader. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1203 |
if (ik != NULL && |
41182 | 1204 |
ik->is_shared_boot_class() && class_loader.is_null()) { |
1205 |
Handle protection_domain; |
|
1206 |
return load_shared_class(ik, class_loader, protection_domain, THREAD); |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1207 |
} |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1208 |
return NULL; |
1 | 1209 |
} |
1210 |
||
36508 | 1211 |
// Check if a shared class can be loaded by the specific classloader: |
1212 |
// |
|
1213 |
// NULL classloader: |
|
1214 |
// - Module class from "modules" jimage. ModuleEntry must be defined in the classloader. |
|
1215 |
// - Class from -Xbootclasspath/a. The class has no defined PackageEntry, or must |
|
1216 |
// be defined in an unnamed module. |
|
1217 |
bool SystemDictionary::is_shared_class_visible(Symbol* class_name, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1218 |
InstanceKlass* ik, |
36508 | 1219 |
Handle class_loader, TRAPS) { |
42876
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1220 |
assert(!ModuleEntryTable::javabase_moduleEntry()->is_patched(), |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1221 |
"Cannot use sharing if java.base is patched"); |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1222 |
ResourceMark rm; |
36508 | 1223 |
int path_index = ik->shared_classpath_index(); |
1224 |
SharedClassPathEntry* ent = |
|
1225 |
(SharedClassPathEntry*)FileMapInfo::shared_classpath(path_index); |
|
1226 |
if (!Universe::is_module_initialized()) { |
|
41739
4a4b9f6a4306
8167333: Invalid source path info might be used when creating ClassFileStream after CFLH transforms a shared classes in some cases
jiangli
parents:
41182
diff
changeset
|
1227 |
assert(ent != NULL && ent->is_jrt(), |
36508 | 1228 |
"Loading non-bootstrap classes before the module system is initialized"); |
1229 |
assert(class_loader.is_null(), "sanity"); |
|
1230 |
return true; |
|
1231 |
} |
|
1232 |
// Get the pkg_entry from the classloader |
|
1233 |
TempNewSymbol pkg_name = NULL; |
|
1234 |
PackageEntry* pkg_entry = NULL; |
|
1235 |
ModuleEntry* mod_entry = NULL; |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1236 |
const char* pkg_string = NULL; |
36508 | 1237 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1238 |
pkg_name = InstanceKlass::package_from_name(class_name, CHECK_false); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1239 |
if (pkg_name != NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1240 |
pkg_string = pkg_name->as_C_string(); |
36508 | 1241 |
if (loader_data != NULL) { |
1242 |
pkg_entry = loader_data->packages()->lookup_only(pkg_name); |
|
1243 |
} |
|
1244 |
if (pkg_entry != NULL) { |
|
1245 |
mod_entry = pkg_entry->module(); |
|
1246 |
} |
|
1247 |
} |
|
1248 |
||
42876
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1249 |
// If the archived class is from a module that has been patched at runtime, |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1250 |
// the class cannot be loaded from the archive. |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1251 |
if (mod_entry != NULL && mod_entry->is_patched()) { |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1252 |
return false; |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1253 |
} |
ff8ff9dcccec
8168797: do not load any archived classes from a patched module
jiangli
parents:
42650
diff
changeset
|
1254 |
|
36508 | 1255 |
if (class_loader.is_null()) { |
41739
4a4b9f6a4306
8167333: Invalid source path info might be used when creating ClassFileStream after CFLH transforms a shared classes in some cases
jiangli
parents:
41182
diff
changeset
|
1256 |
assert(ent != NULL, "Shared class for NULL classloader must have valid SharedClassPathEntry"); |
36508 | 1257 |
// The NULL classloader can load archived class originated from the |
1258 |
// "modules" jimage and the -Xbootclasspath/a. For class from the |
|
1259 |
// "modules" jimage, the PackageEntry/ModuleEntry must be defined |
|
1260 |
// by the NULL classloader. |
|
1261 |
if (mod_entry != NULL) { |
|
1262 |
// PackageEntry/ModuleEntry is found in the classloader. Check if the |
|
1263 |
// ModuleEntry's location agrees with the archived class' origination. |
|
1264 |
if (ent->is_jrt() && mod_entry->location()->starts_with("jrt:")) { |
|
1265 |
return true; // Module class from the "module" jimage |
|
1266 |
} |
|
1267 |
} |
|
1268 |
||
1269 |
// If the archived class is not from the "module" jimage, the class can be |
|
1270 |
// loaded by the NULL classloader if |
|
1271 |
// |
|
1272 |
// 1. the class is from the unamed package |
|
1273 |
// 2. or, the class is not from a module defined in the NULL classloader |
|
1274 |
// 3. or, the class is from an unamed module |
|
1275 |
if (!ent->is_jrt() && ik->is_shared_boot_class()) { |
|
1276 |
// the class is from the -Xbootclasspath/a |
|
1277 |
if (pkg_string == NULL || |
|
1278 |
pkg_entry == NULL || |
|
1279 |
pkg_entry->in_unnamed_module()) { |
|
1280 |
assert(mod_entry == NULL || |
|
46387 | 1281 |
mod_entry == loader_data->unnamed_module(), |
36508 | 1282 |
"the unnamed module is not defined in the classloader"); |
1283 |
return true; |
|
1284 |
} |
|
1285 |
} |
|
1286 |
return false; |
|
1287 |
} else { |
|
1288 |
bool res = SystemDictionaryShared::is_shared_class_visible_for_classloader( |
|
1289 |
ik, class_loader, pkg_string, pkg_name, |
|
1290 |
pkg_entry, mod_entry, CHECK_(false)); |
|
1291 |
return res; |
|
1292 |
} |
|
1293 |
} |
|
1294 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1295 |
InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1296 |
Handle class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1297 |
Handle protection_domain, TRAPS) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1298 |
|
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1299 |
if (ik != NULL) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1300 |
Symbol* class_name = ik->name(); |
1 | 1301 |
|
36508 | 1302 |
bool visible = is_shared_class_visible( |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1303 |
class_name, ik, class_loader, CHECK_NULL); |
36508 | 1304 |
if (!visible) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1305 |
return NULL; |
36508 | 1306 |
} |
1307 |
||
38709
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1308 |
// Resolve the superclass and interfaces. They must be the same |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1309 |
// as in dump time, because the layout of <ik> depends on |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1310 |
// the specific layout of ik->super() and ik->local_interfaces(). |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1311 |
// |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1312 |
// If unexpected superclass or interfaces are found, we cannot |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1313 |
// load <ik> from the shared archive. |
1 | 1314 |
|
1315 |
if (ik->super() != NULL) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1316 |
Symbol* cn = ik->super()->name(); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1317 |
Klass *s = resolve_super_or_fail(class_name, cn, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1318 |
class_loader, protection_domain, true, CHECK_NULL); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1319 |
if (s != ik->super()) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1320 |
// The dynamically resolved super class is not the same as the one we used during dump time, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1321 |
// so we cannot use ik. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1322 |
return NULL; |
38709
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1323 |
} else { |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1324 |
assert(s->is_shared(), "must be"); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1325 |
} |
1 | 1326 |
} |
1327 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1328 |
Array<Klass*>* interfaces = ik->local_interfaces(); |
1 | 1329 |
int num_interfaces = interfaces->length(); |
1330 |
for (int index = 0; index < num_interfaces; index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1331 |
Klass* k = interfaces->at(index); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1332 |
Symbol* name = k->name(); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1333 |
Klass* i = resolve_super_or_fail(class_name, name, class_loader, protection_domain, false, CHECK_NULL); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1334 |
if (k != i) { |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1335 |
// The dynamically resolved interface class is not the same as the one we used during dump time, |
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1336 |
// so we cannot use ik. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1337 |
return NULL; |
38709
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1338 |
} else { |
835ea8e8b295
8145247: incorrect comment in SystemDictionary::load_shared_class
iklam
parents:
38658
diff
changeset
|
1339 |
assert(i->is_shared(), "must be"); |
34257
4be3504cc03b
8140802: Clean up and refactor of class loading code for CDS
iklam
parents:
33612
diff
changeset
|
1340 |
} |
1 | 1341 |
} |
1342 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1343 |
InstanceKlass* new_ik = KlassFactory::check_shared_class_file_load_hook( |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1344 |
ik, class_name, class_loader, protection_domain, CHECK_NULL); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1345 |
if (new_ik != NULL) { |
41182 | 1346 |
// The class is changed by CFLH. Return the new class. The shared class is |
1347 |
// not used. |
|
1348 |
return new_ik; |
|
1349 |
} |
|
1350 |
||
1 | 1351 |
// Adjust methods to recover missing data. They need addresses for |
1352 |
// interpreter entry points and their default native method address |
|
1353 |
// must be reset. |
|
1354 |
||
1355 |
// Updating methods must be done under a lock so multiple |
|
1356 |
// threads don't update these in parallel |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1357 |
// |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1358 |
// Shared classes are all currently loaded by either the bootstrap or |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1359 |
// internal parallel class loaders, so this will never cause a deadlock |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1360 |
// on a custom class loader lock. |
1 | 1361 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1362 |
ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader()); |
1 | 1363 |
{ |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
1364 |
HandleMark hm(THREAD); |
1 | 1365 |
Handle lockObject = compute_loader_lock_object(class_loader, THREAD); |
1366 |
check_loader_lock_contention(lockObject, THREAD); |
|
1367 |
ObjectLocker ol(lockObject, THREAD, true); |
|
40016 | 1368 |
// prohibited package check assumes all classes loaded from archive call |
1369 |
// restore_unshareable_info which calls ik->set_package() |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1370 |
ik->restore_unshareable_info(loader_data, protection_domain, CHECK_NULL); |
1 | 1371 |
} |
1372 |
||
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46435
diff
changeset
|
1373 |
ik->print_class_load_logging(loader_data, NULL, NULL); |
36508 | 1374 |
|
1375 |
// For boot loader, ensure that GetSystemPackage knows that a class in this |
|
1376 |
// package was loaded. |
|
1377 |
if (class_loader.is_null()) { |
|
1378 |
int path_index = ik->shared_classpath_index(); |
|
1379 |
ResourceMark rm; |
|
1380 |
ClassLoader::add_package(ik->name()->as_C_string(), path_index, THREAD); |
|
1 | 1381 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1382 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1383 |
if (DumpLoadedClassList != NULL && classlist_file->is_open()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1384 |
// Only dump the classes that can be stored into CDS archive |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1385 |
if (SystemDictionaryShared::is_sharing_possible(loader_data)) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1386 |
ResourceMark rm(THREAD); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1387 |
classlist_file->print_cr("%s", ik->name()->as_C_string()); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1388 |
classlist_file->flush(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1389 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1390 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1391 |
|
1 | 1392 |
// notify a class loaded from shared object |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1393 |
ClassLoadingService::notify_class_loaded(ik, true /* shared class */); |
1 | 1394 |
} |
42650 | 1395 |
|
1396 |
ik->set_has_passed_fingerprint_check(false); |
|
1397 |
if (UseAOT && ik->supers_have_passed_fingerprint_checks()) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1398 |
uint64_t aot_fp = AOTLoader::get_saved_fingerprint(ik); |
42650 | 1399 |
uint64_t cds_fp = ik->get_stored_fingerprint(); |
1400 |
if (aot_fp != 0 && aot_fp == cds_fp) { |
|
1401 |
// This class matches with a class saved in an AOT library |
|
1402 |
ik->set_has_passed_fingerprint_check(true); |
|
1403 |
} else { |
|
1404 |
ResourceMark rm; |
|
1405 |
log_info(class, fingerprint)("%s : expected = " PTR64_FORMAT " actual = " PTR64_FORMAT, ik->external_name(), aot_fp, cds_fp); |
|
1406 |
} |
|
1407 |
} |
|
1 | 1408 |
return ik; |
1409 |
} |
|
26419 | 1410 |
#endif // INCLUDE_CDS |
1 | 1411 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1412 |
InstanceKlass* SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) { |
36508 | 1413 |
|
1 | 1414 |
if (class_loader.is_null()) { |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1415 |
ResourceMark rm; |
36508 | 1416 |
PackageEntry* pkg_entry = NULL; |
1417 |
bool search_only_bootloader_append = false; |
|
1418 |
ClassLoaderData *loader_data = class_loader_data(class_loader); |
|
1419 |
||
1420 |
// Find the package in the boot loader's package entry table. |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1421 |
TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK_NULL); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1422 |
if (pkg_name != NULL) { |
36508 | 1423 |
pkg_entry = loader_data->packages()->lookup_only(pkg_name); |
1424 |
} |
|
1425 |
||
1426 |
// Prior to attempting to load the class, enforce the boot loader's |
|
1427 |
// visibility boundaries. |
|
1428 |
if (!Universe::is_module_initialized()) { |
|
1429 |
// During bootstrapping, prior to module initialization, any |
|
1430 |
// class attempting to be loaded must be checked against the |
|
1431 |
// java.base packages in the boot loader's PackageEntryTable. |
|
1432 |
// No class outside of java.base is allowed to be loaded during |
|
1433 |
// this bootstrapping window. |
|
1434 |
if (!DumpSharedSpaces) { |
|
1435 |
if (pkg_entry == NULL || pkg_entry->in_unnamed_module()) { |
|
1436 |
// Class is either in the unnamed package or in |
|
1437 |
// a named package within the unnamed module. Either |
|
1438 |
// case is outside of java.base, do not attempt to |
|
1439 |
// load the class post java.base definition. If |
|
1440 |
// java.base has not been defined, let the class load |
|
1441 |
// and its package will be checked later by |
|
1442 |
// ModuleEntryTable::verify_javabase_packages. |
|
1443 |
if (ModuleEntryTable::javabase_defined()) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1444 |
return NULL; |
36508 | 1445 |
} |
1446 |
} else { |
|
1447 |
// Check that the class' package is defined within java.base. |
|
1448 |
ModuleEntry* mod_entry = pkg_entry->module(); |
|
1449 |
Symbol* mod_entry_name = mod_entry->name(); |
|
1450 |
if (mod_entry_name->fast_compare(vmSymbols::java_base()) != 0) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1451 |
return NULL; |
36508 | 1452 |
} |
1453 |
} |
|
1454 |
} |
|
1455 |
} else { |
|
1456 |
assert(!DumpSharedSpaces, "Archive dumped after module system initialization"); |
|
1457 |
// After the module system has been initialized, check if the class' |
|
1458 |
// package is in a module defined to the boot loader. |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38709
diff
changeset
|
1459 |
if (pkg_name == NULL || pkg_entry == NULL || pkg_entry->in_unnamed_module()) { |
36508 | 1460 |
// Class is either in the unnamed package, in a named package |
1461 |
// within a module not defined to the boot loader or in a |
|
1462 |
// a named package within the unnamed module. In all cases, |
|
1463 |
// limit visibility to search for the class only in the boot |
|
1464 |
// loader's append path. |
|
1465 |
search_only_bootloader_append = true; |
|
1466 |
} |
|
1467 |
} |
|
1468 |
||
1469 |
// Prior to bootstrapping's module initialization, never load a class outside |
|
1470 |
// of the boot loader's module path |
|
1471 |
assert(Universe::is_module_initialized() || DumpSharedSpaces || |
|
1472 |
!search_only_bootloader_append, |
|
1473 |
"Attempt to load a class outside of boot loader's module path"); |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1474 |
|
1 | 1475 |
// Search the shared system dictionary for classes preloaded into the |
1476 |
// shared spaces. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1477 |
InstanceKlass* k = NULL; |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1478 |
{ |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1479 |
#if INCLUDE_CDS |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1480 |
PerfTraceTime vmtimer(ClassLoader::perf_shared_classload_time()); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1481 |
k = load_shared_class(class_name, class_loader, THREAD); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1482 |
#endif |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1483 |
} |
1 | 1484 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1485 |
if (k == NULL) { |
1 | 1486 |
// Use VM class loader |
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1487 |
PerfTraceTime vmtimer(ClassLoader::perf_sys_classload_time()); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1488 |
k = ClassLoader::load_class(class_name, search_only_bootloader_append, CHECK_NULL); |
1 | 1489 |
} |
1490 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1491 |
// find_or_define_instance_class may return a different InstanceKlass |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1492 |
if (k != NULL) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1493 |
InstanceKlass* defined_k = |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1494 |
find_or_define_instance_class(class_name, class_loader, k, THREAD); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1495 |
if (!HAS_PENDING_EXCEPTION && defined_k != k) { |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1496 |
// If a parallel capable class loader already defined this class, register 'k' for cleanup. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1497 |
assert(defined_k != NULL, "Should have a klass if there's no exception"); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1498 |
loader_data->add_to_deallocate_list(k); |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1499 |
k = defined_k; |
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1500 |
} else if (HAS_PENDING_EXCEPTION) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1501 |
loader_data->add_to_deallocate_list(k); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1502 |
return NULL; |
43948
26f3c55e246e
8173743: Failures during class definition can lead to memory leaks in metaspace
simonis
parents:
42876
diff
changeset
|
1503 |
} |
1 | 1504 |
} |
1505 |
return k; |
|
1506 |
} else { |
|
1507 |
// Use user specified class loader to load class. Call loadClass operation on class_loader. |
|
1508 |
ResourceMark rm(THREAD); |
|
1509 |
||
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1510 |
assert(THREAD->is_Java_thread(), "must be a JavaThread"); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1511 |
JavaThread* jt = (JavaThread*) THREAD; |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1512 |
|
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1513 |
PerfClassTraceTime vmtimer(ClassLoader::perf_app_classload_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1514 |
ClassLoader::perf_app_classload_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1515 |
ClassLoader::perf_app_classload_count(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1516 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1517 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1518 |
PerfClassTraceTime::CLASS_LOAD); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2570
diff
changeset
|
1519 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1520 |
Handle s = java_lang_String::create_from_symbol(class_name, CHECK_NULL); |
1 | 1521 |
// Translate to external class name format, i.e., convert '/' chars to '.' |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1522 |
Handle string = java_lang_String::externalize_classname(s, CHECK_NULL); |
1 | 1523 |
|
1524 |
JavaValue result(T_OBJECT); |
|
1525 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1526 |
InstanceKlass* spec_klass = SystemDictionary::ClassLoader_klass(); |
1 | 1527 |
|
1890 | 1528 |
// Call public unsynchronized loadClass(String) directly for all class loaders |
1529 |
// for parallelCapable class loaders. JDK >=7, loadClass(String, boolean) will |
|
1530 |
// acquire a class-name based lock rather than the class loader object lock. |
|
1531 |
// JDK < 7 already acquire the class loader lock in loadClass(String, boolean), |
|
1532 |
// so the call to loadClassInternal() was not required. |
|
1533 |
// |
|
1534 |
// UnsyncloadClass flag means both call loadClass(String) and do |
|
1535 |
// not acquire the class loader lock even for class loaders that are |
|
1536 |
// not parallelCapable. This was a risky transitional |
|
1537 |
// flag for diagnostic purposes only. It is risky to call |
|
1 | 1538 |
// custom class loaders without synchronization. |
1539 |
// WARNING If a custom class loader does NOT synchronizer findClass, or callers of |
|
1890 | 1540 |
// findClass, the UnsyncloadClass flag risks unexpected timing bugs in the field. |
1 | 1541 |
// Do NOT assume this will be supported in future releases. |
1890 | 1542 |
// |
1543 |
// Added MustCallLoadClassInternal in case we discover in the field |
|
1544 |
// a customer that counts on this call |
|
1545 |
if (MustCallLoadClassInternal && has_loadClassInternal()) { |
|
1 | 1546 |
JavaCalls::call_special(&result, |
1547 |
class_loader, |
|
1548 |
spec_klass, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1549 |
vmSymbols::loadClassInternal_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1550 |
vmSymbols::string_class_signature(), |
1 | 1551 |
string, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1552 |
CHECK_NULL); |
1 | 1553 |
} else { |
1554 |
JavaCalls::call_virtual(&result, |
|
1555 |
class_loader, |
|
1556 |
spec_klass, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1557 |
vmSymbols::loadClass_name(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1558 |
vmSymbols::string_class_signature(), |
1 | 1559 |
string, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1560 |
CHECK_NULL); |
1 | 1561 |
} |
1562 |
||
1563 |
assert(result.get_type() == T_OBJECT, "just checking"); |
|
1564 |
oop obj = (oop) result.get_jobject(); |
|
1565 |
||
1566 |
// Primitive classes return null since forName() can not be |
|
1567 |
// used to obtain any of the Class objects representing primitives or void |
|
1568 |
if ((obj != NULL) && !(java_lang_Class::is_primitive(obj))) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1569 |
InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(obj)); |
1 | 1570 |
// For user defined Java class loaders, check that the name returned is |
1571 |
// the same as that requested. This check is done for the bootstrap |
|
1572 |
// loader when parsing the class file. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1573 |
if (class_name == k->name()) { |
1 | 1574 |
return k; |
1575 |
} |
|
1576 |
} |
|
1577 |
// Class is not found or has the wrong name, return NULL |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1578 |
return NULL; |
1 | 1579 |
} |
1580 |
} |
|
1581 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1582 |
void SystemDictionary::define_instance_class(InstanceKlass* k, TRAPS) { |
1 | 1583 |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
1584 |
HandleMark hm(THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1585 |
ClassLoaderData* loader_data = k->class_loader_data(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1586 |
Handle class_loader_h(THREAD, loader_data->class_loader()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1587 |
|
1890 | 1588 |
// for bootstrap and other parallel classloaders don't acquire lock, |
1589 |
// use placeholder token |
|
1590 |
// If a parallelCapable class loader calls define_instance_class instead of |
|
1591 |
// find_or_define_instance_class to get here, we have a timing |
|
1592 |
// hole with systemDictionary updates and check_constraints |
|
1593 |
if (!class_loader_h.is_null() && !is_parallelCapable(class_loader_h)) { |
|
1 | 1594 |
assert(ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, |
1595 |
compute_loader_lock_object(class_loader_h, THREAD)), |
|
1596 |
"define called without lock"); |
|
1597 |
} |
|
1598 |
||
1599 |
// Check class-loading constraints. Throw exception if violation is detected. |
|
1600 |
// Grabs and releases SystemDictionary_lock |
|
1601 |
// The check_constraints/find_class call and update_dictionary sequence |
|
1602 |
// must be "atomic" for a specific class/classloader pair so we never |
|
1603 |
// define two different instanceKlasses for that class/classloader pair. |
|
1604 |
// Existing classloaders will call define_instance_class with the |
|
1605 |
// classloader lock held |
|
1606 |
// Parallel classloaders will call find_or_define_instance_class |
|
1607 |
// which will require a token to perform the define class |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1608 |
Symbol* name_h = k->name(); |
46729 | 1609 |
Dictionary* dictionary = loader_data->dictionary(); |
1610 |
unsigned int d_hash = dictionary->compute_hash(name_h); |
|
1611 |
int d_index = dictionary->hash_to_index(d_hash); |
|
1 | 1612 |
check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK); |
1613 |
||
13753
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1614 |
// Register class just loaded with class loader (placed in Vector) |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1615 |
// Note we do this before updating the dictionary, as this can |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1616 |
// fail with an OutOfMemoryError (if it does, we will *not* put this |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1617 |
// class in the dictionary and will not update the class hierarchy). |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1618 |
// JVMTI FollowReferences needs to find the classes this way. |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1619 |
if (k->class_loader() != NULL) { |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1620 |
methodHandle m(THREAD, Universe::loader_addClass_method()); |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1621 |
JavaValue result(T_VOID); |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1622 |
JavaCallArguments args(class_loader_h); |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1623 |
args.push_oop(Handle(THREAD, k->java_mirror())); |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1624 |
JavaCalls::call(&result, m, &args, CHECK); |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1625 |
} |
1df4fd11c5b8
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
13738
diff
changeset
|
1626 |
|
1 | 1627 |
// Add the new class. We need recompile lock during update of CHA. |
1628 |
{ |
|
46729 | 1629 |
unsigned int p_hash = placeholders()->compute_hash(name_h); |
1 | 1630 |
int p_index = placeholders()->hash_to_index(p_hash); |
1631 |
||
1632 |
MutexLocker mu_r(Compile_lock, THREAD); |
|
1633 |
||
1634 |
// Add to class hierarchy, initialize vtables, and do possible |
|
1635 |
// deoptimizations. |
|
1636 |
add_to_hierarchy(k, CHECK); // No exception, but can block |
|
1637 |
||
1638 |
// Add to systemDictionary - so other classes can see it. |
|
1639 |
// Grabs and releases SystemDictionary_lock |
|
1640 |
update_dictionary(d_index, d_hash, p_index, p_hash, |
|
1641 |
k, class_loader_h, THREAD); |
|
1642 |
} |
|
1643 |
k->eager_initialize(THREAD); |
|
1644 |
||
1645 |
// notify jvmti |
|
1646 |
if (JvmtiExport::should_post_class_load()) { |
|
1647 |
assert(THREAD->is_Java_thread(), "thread->is_Java_thread()"); |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1648 |
JvmtiExport::post_class_load((JavaThread *) THREAD, k); |
1 | 1649 |
|
1650 |
} |
|
42639
762117d57d05
8170672: Event-based tracing to support classloader instances
mgronlun
parents:
42575
diff
changeset
|
1651 |
class_define_event(k, loader_data); |
1 | 1652 |
} |
1653 |
||
1654 |
// Support parallel classloading |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1655 |
// All parallel class loaders, including bootstrap classloader |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1656 |
// lock a placeholder entry for this class/class_loader pair |
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1657 |
// to allow parallel defines of different classes for this class loader |
1890 | 1658 |
// With AllowParallelDefine flag==true, in case they do not synchronize around |
1659 |
// FindLoadedClass/DefineClass, calls, we check for parallel |
|
1 | 1660 |
// loading for them, wait if a defineClass is in progress |
1661 |
// and return the initial requestor's results |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1662 |
// This flag does not apply to the bootstrap classloader. |
1890 | 1663 |
// With AllowParallelDefine flag==false, call through to define_instance_class |
1664 |
// which will throw LinkageError: duplicate class definition. |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1665 |
// False is the requested default. |
1 | 1666 |
// For better performance, the class loaders should synchronize |
1890 | 1667 |
// findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they |
1 | 1668 |
// potentially waste time reading and parsing the bytestream. |
1669 |
// Note: VM callers should ensure consistency of k/class_name,class_loader |
|
40016 | 1670 |
// Be careful when modifying this code: once you have run |
1671 |
// placeholders()->find_and_add(PlaceholderTable::DEFINE_CLASS), |
|
1672 |
// you need to find_and_remove it before returning. |
|
1673 |
// So be careful to not exit with a CHECK_ macro betweeen these calls. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1674 |
InstanceKlass* SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1675 |
InstanceKlass* k, TRAPS) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1676 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1677 |
Symbol* name_h = k->name(); // passed in class_name may be null |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1678 |
ClassLoaderData* loader_data = class_loader_data(class_loader); |
46729 | 1679 |
Dictionary* dictionary = loader_data->dictionary(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1680 |
|
46729 | 1681 |
unsigned int d_hash = dictionary->compute_hash(name_h); |
1682 |
int d_index = dictionary->hash_to_index(d_hash); |
|
1 | 1683 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1684 |
// Hold SD lock around find_class and placeholder creation for DEFINE_CLASS |
46729 | 1685 |
unsigned int p_hash = placeholders()->compute_hash(name_h); |
1 | 1686 |
int p_index = placeholders()->hash_to_index(p_hash); |
1687 |
PlaceholderEntry* probe; |
|
1688 |
||
1689 |
{ |
|
1690 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
1691 |
// First check if class already defined |
|
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1692 |
if (UnsyncloadClass || (is_parallelDefine(class_loader))) { |
46729 | 1693 |
InstanceKlass* check = find_class(d_index, d_hash, name_h, dictionary); |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1694 |
if (check != NULL) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1695 |
return check; |
4445
1356c4b003de
6893504: LinkageError for bootstrap duplicate class definitions.
acorn
parents:
4094
diff
changeset
|
1696 |
} |
1 | 1697 |
} |
1698 |
||
1699 |
// Acquire define token for this class/classloader |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1700 |
probe = placeholders()->find_and_add(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, NULL, THREAD); |
1890 | 1701 |
// Wait if another thread defining in parallel |
1702 |
// All threads wait - even those that will throw duplicate class: otherwise |
|
1703 |
// caller is surprised by LinkageError: duplicate, but findLoadedClass fails |
|
1704 |
// if other thread has not finished updating dictionary |
|
1705 |
while (probe->definer() != NULL) { |
|
1706 |
SystemDictionary_lock->wait(); |
|
1707 |
} |
|
1708 |
// Only special cases allow parallel defines and can use other thread's results |
|
1709 |
// Other cases fall through, and may run into duplicate defines |
|
1710 |
// caught by finding an entry in the SystemDictionary |
|
14488 | 1711 |
if ((UnsyncloadClass || is_parallelDefine(class_loader)) && (probe->instance_klass() != NULL)) { |
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
1712 |
placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD); |
1890 | 1713 |
SystemDictionary_lock->notify_all(); |
1 | 1714 |
#ifdef ASSERT |
46729 | 1715 |
InstanceKlass* check = find_class(d_index, d_hash, name_h, dictionary); |
1890 | 1716 |
assert(check != NULL, "definer missed recording success"); |
1 | 1717 |
#endif |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1718 |
return probe->instance_klass(); |
1 | 1719 |
} else { |
1890 | 1720 |
// This thread will define the class (even if earlier thread tried and had an error) |
1721 |
probe->set_definer(THREAD); |
|
1 | 1722 |
} |
1723 |
} |
|
1724 |
||
1725 |
define_instance_class(k, THREAD); |
|
1726 |
||
1727 |
Handle linkage_exception = Handle(); // null handle |
|
1728 |
||
1729 |
// definer must notify any waiting threads |
|
1730 |
{ |
|
1731 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1732 |
PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, name_h, loader_data); |
1 | 1733 |
assert(probe != NULL, "DEFINE_CLASS placeholder lost?"); |
1734 |
if (probe != NULL) { |
|
1735 |
if (HAS_PENDING_EXCEPTION) { |
|
1736 |
linkage_exception = Handle(THREAD,PENDING_EXCEPTION); |
|
1737 |
CLEAR_PENDING_EXCEPTION; |
|
1738 |
} else { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1739 |
probe->set_instance_klass(k); |
1 | 1740 |
} |
1741 |
probe->set_definer(NULL); |
|
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
1742 |
placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD); |
1 | 1743 |
SystemDictionary_lock->notify_all(); |
1744 |
} |
|
1745 |
} |
|
1746 |
||
1747 |
// Can't throw exception while holding lock due to rank ordering |
|
1748 |
if (linkage_exception() != NULL) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1749 |
THROW_OOP_(linkage_exception(), NULL); // throws exception and returns |
1 | 1750 |
} |
1751 |
||
1752 |
return k; |
|
1753 |
} |
|
46729 | 1754 |
|
1 | 1755 |
Handle SystemDictionary::compute_loader_lock_object(Handle class_loader, TRAPS) { |
1756 |
// If class_loader is NULL we synchronize on _system_loader_lock_obj |
|
1757 |
if (class_loader.is_null()) { |
|
1758 |
return Handle(THREAD, _system_loader_lock_obj); |
|
1759 |
} else { |
|
1760 |
return class_loader; |
|
1761 |
} |
|
1762 |
} |
|
1763 |
||
1764 |
// This method is added to check how often we have to wait to grab loader |
|
1765 |
// lock. The results are being recorded in the performance counters defined in |
|
1766 |
// ClassLoader::_sync_systemLoaderLockContentionRate and |
|
1767 |
// ClassLoader::_sync_nonSystemLoaderLockConteionRate. |
|
1768 |
void SystemDictionary::check_loader_lock_contention(Handle loader_lock, TRAPS) { |
|
1769 |
if (!UsePerfData) { |
|
1770 |
return; |
|
1771 |
} |
|
1772 |
||
1773 |
assert(!loader_lock.is_null(), "NULL lock object"); |
|
1774 |
||
1775 |
if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader_lock) |
|
1776 |
== ObjectSynchronizer::owner_other) { |
|
1777 |
// contention will likely happen, so increment the corresponding |
|
1778 |
// contention counter. |
|
1779 |
if (loader_lock() == _system_loader_lock_obj) { |
|
1780 |
ClassLoader::sync_systemLoaderLockContentionRate()->inc(); |
|
1781 |
} else { |
|
1782 |
ClassLoader::sync_nonSystemLoaderLockContentionRate()->inc(); |
|
1783 |
} |
|
1784 |
} |
|
1785 |
} |
|
1786 |
||
1787 |
// ---------------------------------------------------------------------------- |
|
1788 |
// Lookup |
|
1789 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1790 |
InstanceKlass* SystemDictionary::find_class(int index, unsigned int hash, |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1791 |
Symbol* class_name, |
46729 | 1792 |
Dictionary* dictionary) { |
1 | 1793 |
assert_locked_or_safepoint(SystemDictionary_lock); |
46729 | 1794 |
return dictionary->find_class(index, hash, class_name); |
1 | 1795 |
} |
1796 |
||
1797 |
||
1798 |
// Basic find on classes in the midst of being loaded |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1799 |
Symbol* SystemDictionary::find_placeholder(Symbol* class_name, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1800 |
ClassLoaderData* loader_data) { |
1 | 1801 |
assert_locked_or_safepoint(SystemDictionary_lock); |
46729 | 1802 |
unsigned int p_hash = placeholders()->compute_hash(class_name); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
1803 |
int p_index = placeholders()->hash_to_index(p_hash); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1804 |
return placeholders()->find_entry(p_index, p_hash, class_name, loader_data); |
1 | 1805 |
} |
1806 |
||
1807 |
||
1808 |
// Used for assertions and verification only |
|
46729 | 1809 |
// Precalculating the hash and index is an optimization because there are many lookups |
1810 |
// before adding the class. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1811 |
InstanceKlass* SystemDictionary::find_class(Symbol* class_name, ClassLoaderData* loader_data) { |
46729 | 1812 |
assert_locked_or_safepoint(SystemDictionary_lock); |
1 | 1813 |
#ifndef ASSERT |
16680
960505df90e7
8011343: Add new flag for verifying the heap during startup
johnc
parents:
16631
diff
changeset
|
1814 |
guarantee(VerifyBeforeGC || |
960505df90e7
8011343: Add new flag for verifying the heap during startup
johnc
parents:
16631
diff
changeset
|
1815 |
VerifyDuringGC || |
960505df90e7
8011343: Add new flag for verifying the heap during startup
johnc
parents:
16631
diff
changeset
|
1816 |
VerifyBeforeExit || |
960505df90e7
8011343: Add new flag for verifying the heap during startup
johnc
parents:
16631
diff
changeset
|
1817 |
VerifyDuringStartup || |
1 | 1818 |
VerifyAfterGC, "too expensive"); |
1819 |
#endif |
|
1820 |
||
46729 | 1821 |
Dictionary* dictionary = loader_data->dictionary(); |
1822 |
unsigned int d_hash = dictionary->compute_hash(class_name); |
|
1823 |
int d_index = dictionary->hash_to_index(d_hash); |
|
1824 |
return find_class(d_index, d_hash, class_name, dictionary); |
|
1 | 1825 |
} |
1826 |
||
1827 |
||
1828 |
// ---------------------------------------------------------------------------- |
|
1829 |
// Update hierachy. This is done before the new klass has been added to the SystemDictionary. The Recompile_lock |
|
1830 |
// is held, to ensure that the compiler is not using the class hierachy, and that deoptimization will kick in |
|
1831 |
// before a new class is used. |
|
1832 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1833 |
void SystemDictionary::add_to_hierarchy(InstanceKlass* k, TRAPS) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1834 |
assert(k != NULL, "just checking"); |
8314
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
1835 |
assert_locked_or_safepoint(Compile_lock); |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
1836 |
|
1 | 1837 |
// Link into hierachy. Make sure the vtables are initialized before linking into |
1838 |
k->append_to_sibling_list(); // add to superklass/sibling list |
|
1839 |
k->process_interfaces(THREAD); // handle all "implements" declarations |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1840 |
k->set_init_state(InstanceKlass::loaded); |
1 | 1841 |
// Now flush all code that depended on old class hierarchy. |
1842 |
// Note: must be done *after* linking k into the hierarchy (was bug 12/9/97) |
|
1843 |
// Also, first reinitialize vtable because it may have gotten out of synch |
|
1844 |
// while the new class wasn't connected to the class hierarchy. |
|
28374
0558e321c027
8067836: The Universe::flush_foo methods belong in CodeCache.
coleenp
parents:
27694
diff
changeset
|
1845 |
CodeCache::flush_dependents_on(k); |
1 | 1846 |
} |
1847 |
||
1848 |
// ---------------------------------------------------------------------------- |
|
1849 |
// GC support |
|
1850 |
||
1851 |
void SystemDictionary::always_strong_oops_do(OopClosure* blk) { |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1852 |
roots_oops_do(blk, NULL); |
1 | 1853 |
} |
1854 |
||
18025 | 1855 |
|
20405 | 1856 |
#ifdef ASSERT |
1857 |
class VerifySDReachableAndLiveClosure : public OopClosure { |
|
1858 |
private: |
|
1859 |
BoolObjectClosure* _is_alive; |
|
1860 |
||
1861 |
template <class T> void do_oop_work(T* p) { |
|
1862 |
oop obj = oopDesc::load_decode_heap_oop(p); |
|
46729 | 1863 |
guarantee(_is_alive->do_object_b(obj), "Oop in protection domain cache table must be live"); |
20405 | 1864 |
} |
1865 |
||
1866 |
public: |
|
1867 |
VerifySDReachableAndLiveClosure(BoolObjectClosure* is_alive) : OopClosure(), _is_alive(is_alive) { } |
|
1868 |
||
1869 |
virtual void do_oop(oop* p) { do_oop_work(p); } |
|
1870 |
virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
1871 |
}; |
|
1872 |
#endif |
|
1873 |
||
15188
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
1874 |
// Assumes classes in the SystemDictionary are only unloaded at a safepoint |
3916ac601e04
7199207: NPG: Crash in PlaceholderTable::verify after StackOverflow
acorn
parents:
14588
diff
changeset
|
1875 |
// Note: anonymous classes are not in the SD. |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29081
diff
changeset
|
1876 |
bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive, |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1877 |
GCTimer* gc_timer, |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1878 |
bool do_cleaning) { |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1879 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1880 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1881 |
bool unloading_occurred; |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1882 |
{ |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1883 |
GCTraceTime(Debug, gc, phases) t("ClassLoaderData", gc_timer); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1884 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1885 |
// First, mark for unload all ClassLoaderData referencing a dead class loader. |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1886 |
unloading_occurred = ClassLoaderDataGraph::do_unloading(is_alive, |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1887 |
do_cleaning); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1888 |
} |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1889 |
|
26174
ca46a107cb78
8054402: "klass->is_loader_alive(_is_alive)) failed: must be alive" for anonymous classes
thartmann
parents:
25492
diff
changeset
|
1890 |
if (unloading_occurred) { |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1891 |
GCTraceTime(Debug, gc, phases) t("Dictionary", gc_timer); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1892 |
constraints()->purge_loader_constraints(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1893 |
resolution_errors()->purge_resolution_errors(); |
20405 | 1894 |
} |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1895 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1896 |
{ |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1897 |
GCTraceTime(Debug, gc, phases) t("ProtectionDomainCacheTable", gc_timer); |
46729 | 1898 |
// Oops referenced by the protection domain cache table may get unreachable independently |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1899 |
// of the class loader (eg. cached protection domain oops). So we need to |
46729 | 1900 |
// explicitly unlink them here. |
1901 |
_pd_cache_table->unlink(is_alive); |
|
1902 |
||
20405 | 1903 |
#ifdef ASSERT |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1904 |
VerifySDReachableAndLiveClosure cl(is_alive); |
46729 | 1905 |
_pd_cache_table->oops_do(&cl); |
20405 | 1906 |
#endif |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1907 |
} |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1908 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1909 |
if (do_cleaning) { |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1910 |
GCTraceTime(Debug, gc, phases) t("ResolvedMethodTable", gc_timer); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1911 |
ResolvedMethodTable::unlink(is_alive); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1912 |
} |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1913 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1914 |
return unloading_occurred; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1915 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1916 |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1917 |
void SystemDictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) { |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1918 |
strong->do_oop(&_java_system_loader); |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1919 |
strong->do_oop(&_system_loader_lock_obj); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1920 |
CDS_ONLY(SystemDictionaryShared::roots_oops_do(strong);) |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1921 |
|
46729 | 1922 |
// Do strong roots marking if the closures are the same. |
1923 |
if (strong == weak || !ClassUnloading) { |
|
1924 |
// Only the protection domain oops contain references into the heap. Iterate |
|
1925 |
// over all of them. |
|
1926 |
_pd_cache_table->oops_do(strong); |
|
1927 |
} else { |
|
1928 |
if (weak != NULL) { |
|
1929 |
_pd_cache_table->oops_do(weak); |
|
1930 |
} |
|
1931 |
} |
|
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1932 |
|
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1933 |
// Visit extra methods |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1934 |
invoke_method_table()->oops_do(strong); |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1935 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1936 |
if (weak != NULL) { |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1937 |
ResolvedMethodTable::oops_do(weak); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1938 |
} |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1939 |
} |
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1940 |
|
1 | 1941 |
void SystemDictionary::oops_do(OopClosure* f) { |
1942 |
f->do_oop(&_java_system_loader); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1943 |
f->do_oop(&_system_loader_lock_obj); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1944 |
CDS_ONLY(SystemDictionaryShared::oops_do(f);) |
1 | 1945 |
|
46729 | 1946 |
// Only the protection domain oops contain references into the heap. Iterate |
1947 |
// over all of them. |
|
1948 |
_pd_cache_table->oops_do(f); |
|
1 | 1949 |
|
2534 | 1950 |
// Visit extra methods |
7104 | 1951 |
invoke_method_table()->oops_do(f); |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1952 |
|
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
1953 |
ResolvedMethodTable::oops_do(f); |
1 | 1954 |
} |
1955 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1956 |
// CDS: scan and relocate all classes in the system dictionary. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1957 |
void SystemDictionary::classes_do(MetaspaceClosure* it) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1958 |
ClassLoaderData::the_null_class_loader_data()->dictionary()->classes_do(it); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1959 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1960 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1961 |
// CDS: scan and relocate all classes referenced by _well_known_klasses[]. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1962 |
void SystemDictionary::well_known_klasses_do(MetaspaceClosure* it) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1963 |
for (int id = FIRST_WKID; id < WKID_LIMIT; id++) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1964 |
it->push(well_known_klass_addr((WKID)id)); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1965 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1966 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
1967 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1968 |
void SystemDictionary::methods_do(void f(Method*)) { |
46380
4a51438196cf
8026985: Rewrite SystemDictionary::classes_do and Dictionary::classes_do to use KlassClosure
coleenp
parents:
46329
diff
changeset
|
1969 |
// Walk methods in loaded classes |
4a51438196cf
8026985: Rewrite SystemDictionary::classes_do and Dictionary::classes_do to use KlassClosure
coleenp
parents:
46329
diff
changeset
|
1970 |
ClassLoaderDataGraph::methods_do(f); |
4a51438196cf
8026985: Rewrite SystemDictionary::classes_do and Dictionary::classes_do to use KlassClosure
coleenp
parents:
46329
diff
changeset
|
1971 |
// Walk method handle intrinsics |
7104 | 1972 |
invoke_method_table()->methods_do(f); |
1 | 1973 |
} |
1974 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1975 |
void SystemDictionary::remove_classes_in_error_state() { |
46729 | 1976 |
ClassLoaderData::the_null_class_loader_data()->dictionary()->remove_classes_in_error_state(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1977 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
1978 |
|
1 | 1979 |
// ---------------------------------------------------------------------------- |
1980 |
// Lazily load klasses |
|
1981 |
||
1982 |
void SystemDictionary::load_abstract_ownable_synchronizer_klass(TRAPS) { |
|
1983 |
// if multiple threads calling this function, only one thread will load |
|
1984 |
// the class. The other threads will find the loaded version once the |
|
1985 |
// class is loaded. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1986 |
Klass* aos = _abstract_ownable_synchronizer_klass; |
1 | 1987 |
if (aos == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1988 |
Klass* k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK); |
1 | 1989 |
// Force a fence to prevent any read before the write completes |
1990 |
OrderAccess::fence(); |
|
33602 | 1991 |
_abstract_ownable_synchronizer_klass = InstanceKlass::cast(k); |
1 | 1992 |
} |
1993 |
} |
|
1994 |
||
1995 |
// ---------------------------------------------------------------------------- |
|
1996 |
// Initialization |
|
1997 |
||
1998 |
void SystemDictionary::initialize(TRAPS) { |
|
1999 |
// Allocate arrays |
|
46729 | 2000 |
_placeholders = new PlaceholderTable(_placeholder_table_size); |
1 | 2001 |
_number_of_modifications = 0; |
7104 | 2002 |
_loader_constraints = new LoaderConstraintTable(_loader_constraint_size); |
2003 |
_resolution_errors = new ResolutionErrorTable(_resolution_error_size); |
|
2004 |
_invoke_method_table = new SymbolPropertyTable(_invoke_method_size); |
|
46729 | 2005 |
_pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize); |
1 | 2006 |
|
2007 |
// Allocate private object used as system class loader lock |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2008 |
_system_loader_lock_obj = oopFactory::new_intArray(0, CHECK); |
1 | 2009 |
// Initialize basic classes |
2010 |
initialize_preloaded_classes(CHECK); |
|
2011 |
} |
|
2012 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2013 |
// Compact table of directions on the initialization of klasses: |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2014 |
static const short wk_init_info[] = { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2015 |
#define WK_KLASS_INIT_INFO(name, symbol, option) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2016 |
( ((int)vmSymbols::VM_SYMBOL_ENUM_NAME(symbol) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2017 |
<< SystemDictionary::CEIL_LG_OPTION_LIMIT) \ |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2018 |
| (int)SystemDictionary::option ), |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2019 |
WK_KLASSES_DO(WK_KLASS_INIT_INFO) |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2020 |
#undef WK_KLASS_INIT_INFO |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2021 |
0 |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2022 |
}; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2023 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2024 |
bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2025 |
assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2026 |
int info = wk_init_info[id - FIRST_WKID]; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2027 |
int sid = (info >> CEIL_LG_OPTION_LIMIT); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2028 |
Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid); |
33602 | 2029 |
InstanceKlass** klassp = &_well_known_klasses[id]; |
37281
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2030 |
|
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2031 |
bool must_load; |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2032 |
#if INCLUDE_JVMCI |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2033 |
if (EnableJVMCI) { |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2034 |
// If JVMCI is enabled we require its classes to be found. |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2035 |
must_load = (init_opt < SystemDictionary::Opt) || (init_opt == SystemDictionary::Jvmci); |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2036 |
} else |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2037 |
#endif |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2038 |
{ |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2039 |
must_load = (init_opt < SystemDictionary::Opt); |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2040 |
} |
c4e7456d6ae1
8144964: JVMCI compilations need to be disabled until the module system is initialized
twisti
parents:
36822
diff
changeset
|
2041 |
|
15432 | 2042 |
if ((*klassp) == NULL) { |
33602 | 2043 |
Klass* k; |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2044 |
if (must_load) { |
33602 | 2045 |
k = resolve_or_fail(symbol, true, CHECK_0); // load required class |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2046 |
} else { |
33602 | 2047 |
k = resolve_or_null(symbol, CHECK_0); // load optional klass |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2048 |
} |
33602 | 2049 |
(*klassp) = (k == NULL) ? NULL : InstanceKlass::cast(k); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2050 |
} |
9116 | 2051 |
return ((*klassp) != NULL); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2052 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2053 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2054 |
void SystemDictionary::initialize_wk_klasses_until(WKID limit_id, WKID &start_id, TRAPS) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2055 |
assert((int)start_id <= (int)limit_id, "IDs are out of order!"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2056 |
for (int id = (int)start_id; id < (int)limit_id; id++) { |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2057 |
assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob"); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2058 |
int info = wk_init_info[id - FIRST_WKID]; |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2059 |
int sid = (info >> CEIL_LG_OPTION_LIMIT); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2060 |
int opt = (info & right_n_bits(CEIL_LG_OPTION_LIMIT)); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2061 |
|
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2062 |
initialize_wk_klass((WKID)id, opt, CHECK); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2063 |
} |
2534 | 2064 |
|
2065 |
// move the starting value forward to the limit: |
|
2066 |
start_id = limit_id; |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2067 |
} |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2068 |
|
1 | 2069 |
void SystemDictionary::initialize_preloaded_classes(TRAPS) { |
4571 | 2070 |
assert(WK_KLASS(Object_klass) == NULL, "preloaded classes should only be initialized once"); |
36508 | 2071 |
|
2072 |
// Create the ModuleEntry for java.base. This call needs to be done here, |
|
2073 |
// after vmSymbols::initialize() is called but before any classes are pre-loaded. |
|
40013 | 2074 |
ClassLoader::classLoader_init2(CHECK); |
36508 | 2075 |
|
1 | 2076 |
// Preload commonly used klasses |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2077 |
WKID scan = FIRST_WKID; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2078 |
// first do Object, then String, Class |
46689
59f0972cf342
8184323: compile-time guard some UseSharedSpaces-only coding with the INCLUDE_CDS macro
mbaesken
parents:
46560
diff
changeset
|
2079 |
#if INCLUDE_CDS |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2080 |
if (UseSharedSpaces) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2081 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Object_klass), scan, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2082 |
// Initialize the constant pool for the Object_class |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2083 |
Object_klass()->constants()->restore_unshareable_info(CHECK); |
13736
5b15a8f57979
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
13728
diff
changeset
|
2084 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
46689
59f0972cf342
8184323: compile-time guard some UseSharedSpaces-only coding with the INCLUDE_CDS macro
mbaesken
parents:
46560
diff
changeset
|
2085 |
} else |
59f0972cf342
8184323: compile-time guard some UseSharedSpaces-only coding with the INCLUDE_CDS macro
mbaesken
parents:
46560
diff
changeset
|
2086 |
#endif |
59f0972cf342
8184323: compile-time guard some UseSharedSpaces-only coding with the INCLUDE_CDS macro
mbaesken
parents:
46560
diff
changeset
|
2087 |
{ |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2088 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2089 |
} |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2090 |
|
12623 | 2091 |
// Calculate offsets for String and Class classes since they are loaded and |
2092 |
// can be used after this point. |
|
2093 |
java_lang_String::compute_offsets(); |
|
10546 | 2094 |
java_lang_Class::compute_offsets(); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2095 |
|
1 | 2096 |
// Fixup mirrors for classes loaded before java.lang.Class. |
2097 |
// These calls iterate over the objects currently in the perm gen |
|
2098 |
// so calling them at this point is matters (not before when there |
|
2099 |
// are fewer objects and not later after there are more objects |
|
2100 |
// in the perm gen. |
|
2101 |
Universe::initialize_basic_type_mirrors(CHECK); |
|
2102 |
Universe::fixup_mirrors(CHECK); |
|
2103 |
||
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2104 |
// do a bunch more: |
4571 | 2105 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Reference_klass), scan, CHECK); |
1 | 2106 |
|
2107 |
// Preload ref klasses and set reference types |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2108 |
InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER); |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
2109 |
InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass)); |
1 | 2110 |
|
35475 | 2111 |
initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2112 |
InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2113 |
InstanceKlass::cast(WK_KLASS(WeakReference_klass))->set_reference_type(REF_WEAK); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2114 |
InstanceKlass::cast(WK_KLASS(FinalReference_klass))->set_reference_type(REF_FINAL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2115 |
InstanceKlass::cast(WK_KLASS(PhantomReference_klass))->set_reference_type(REF_PHANTOM); |
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2116 |
|
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
2117 |
// JSR 292 classes |
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
2118 |
WKID jsr292_group_start = WK_KLASS_ENUM_NAME(MethodHandle_klass); |
10265
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10008
diff
changeset
|
2119 |
WKID jsr292_group_end = WK_KLASS_ENUM_NAME(VolatileCallSite_klass); |
8883
5569135acca3
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
8676
diff
changeset
|
2120 |
initialize_wk_klasses_until(jsr292_group_start, scan, CHECK); |
24322 | 2121 |
initialize_wk_klasses_through(jsr292_group_end, scan, CHECK); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
2122 |
initialize_wk_klasses_until(NOT_JVMCI(WKID_LIMIT) JVMCI_ONLY(FIRST_JVMCI_WKID), scan, CHECK); |
1 | 2123 |
|
4571 | 2124 |
_box_klasses[T_BOOLEAN] = WK_KLASS(Boolean_klass); |
2125 |
_box_klasses[T_CHAR] = WK_KLASS(Character_klass); |
|
2126 |
_box_klasses[T_FLOAT] = WK_KLASS(Float_klass); |
|
2127 |
_box_klasses[T_DOUBLE] = WK_KLASS(Double_klass); |
|
2128 |
_box_klasses[T_BYTE] = WK_KLASS(Byte_klass); |
|
2129 |
_box_klasses[T_SHORT] = WK_KLASS(Short_klass); |
|
2130 |
_box_klasses[T_INT] = WK_KLASS(Integer_klass); |
|
2131 |
_box_klasses[T_LONG] = WK_KLASS(Long_klass); |
|
379
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2132 |
//_box_klasses[T_OBJECT] = WK_KLASS(object_klass); |
10767ca40189
6652736: well known classes in system dictionary are inefficiently processed
jrose
parents:
195
diff
changeset
|
2133 |
//_box_klasses[T_ARRAY] = WK_KLASS(object_klass); |
1 | 2134 |
|
2135 |
{ // Compute whether we should use loadClass or loadClassInternal when loading classes. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2136 |
Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::loadClassInternal_name(), vmSymbols::string_class_signature()); |
1 | 2137 |
_has_loadClassInternal = (method != NULL); |
2138 |
} |
|
2139 |
{ // Compute whether we should use checkPackageAccess or NOT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2140 |
Method* method = InstanceKlass::cast(ClassLoader_klass())->find_method(vmSymbols::checkPackageAccess_name(), vmSymbols::class_protectiondomain_signature()); |
1 | 2141 |
_has_checkPackageAccess = (method != NULL); |
2142 |
} |
|
2143 |
} |
|
2144 |
||
2145 |
// Tells if a given klass is a box (wrapper class, such as java.lang.Integer). |
|
2146 |
// If so, returns the basic type it holds. If not, returns T_OBJECT. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2147 |
BasicType SystemDictionary::box_klass_type(Klass* k) { |
1 | 2148 |
assert(k != NULL, ""); |
2149 |
for (int i = T_BOOLEAN; i < T_VOID+1; i++) { |
|
2150 |
if (_box_klasses[i] == k) |
|
2151 |
return (BasicType)i; |
|
2152 |
} |
|
2153 |
return T_OBJECT; |
|
2154 |
} |
|
2155 |
||
2156 |
// Constraints on class loaders. The details of the algorithm can be |
|
2157 |
// found in the OOPSLA'98 paper "Dynamic Class Loading in the Java |
|
2158 |
// Virtual Machine" by Sheng Liang and Gilad Bracha. The basic idea is |
|
46729 | 2159 |
// that the dictionary needs to maintain a set of contraints that |
1 | 2160 |
// must be satisfied by all classes in the dictionary. |
46729 | 2161 |
// if defining is true, then LinkageError if already in dictionary |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2162 |
// if initiating loader, then ok if InstanceKlass matches existing entry |
1 | 2163 |
|
2164 |
void SystemDictionary::check_constraints(int d_index, unsigned int d_hash, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2165 |
InstanceKlass* k, |
1 | 2166 |
Handle class_loader, bool defining, |
2167 |
TRAPS) { |
|
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2168 |
const char *linkage_error1 = NULL; |
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2169 |
const char *linkage_error2 = NULL; |
1 | 2170 |
{ |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2171 |
Symbol* name = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2172 |
ClassLoaderData *loader_data = class_loader_data(class_loader); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2173 |
|
1 | 2174 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
2175 |
||
46729 | 2176 |
InstanceKlass* check = find_class(d_index, d_hash, name, loader_data->dictionary()); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2177 |
if (check != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2178 |
// if different InstanceKlass - duplicate class definition, |
1 | 2179 |
// else - ok, class loaded by a different thread in parallel, |
2180 |
// we should only have found it if it was done loading and ok to use |
|
46729 | 2181 |
// dictionary only holds instance classes, placeholders |
1 | 2182 |
// also holds array classes |
2183 |
||
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2184 |
assert(check->is_instance_klass(), "noninstance in systemdictionary"); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2185 |
if ((defining == true) || (k != check)) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2186 |
linkage_error1 = "loader (instance of "; |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2187 |
linkage_error2 = "): attempted duplicate class definition for name: \""; |
1 | 2188 |
} else { |
2189 |
return; |
|
2190 |
} |
|
2191 |
} |
|
2192 |
||
2193 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2194 |
Symbol* ph_check = find_placeholder(name, loader_data); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2195 |
assert(ph_check == NULL || ph_check == name, "invalid symbol"); |
1 | 2196 |
#endif |
2197 |
||
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2198 |
if (linkage_error1 == NULL) { |
1 | 2199 |
if (constraints()->check_or_update(k, class_loader, name) == false) { |
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2200 |
linkage_error1 = "loader constraint violation: loader (instance of "; |
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2201 |
linkage_error2 = ") previously initiated loading for a different type with name \""; |
1 | 2202 |
} |
2203 |
} |
|
2204 |
} |
|
2205 |
||
2206 |
// Throw error now if needed (cannot throw while holding |
|
2207 |
// SystemDictionary_lock because of rank ordering) |
|
2208 |
||
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2209 |
if (linkage_error1) { |
1 | 2210 |
ResourceMark rm(THREAD); |
2211 |
const char* class_loader_name = loader_name(class_loader()); |
|
2212 |
char* type_name = k->name()->as_C_string(); |
|
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2213 |
size_t buflen = strlen(linkage_error1) + strlen(class_loader_name) + |
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2214 |
strlen(linkage_error2) + strlen(type_name) + 2; // +2 for '"' and null byte. |
1 | 2215 |
char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); |
33604
ad1cd9269bd4
8139116: Fixes for warning "format not a string literal"
goetz
parents:
33602
diff
changeset
|
2216 |
jio_snprintf(buf, buflen, "%s%s%s%s\"", linkage_error1, class_loader_name, linkage_error2, type_name); |
1 | 2217 |
THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); |
2218 |
} |
|
2219 |
} |
|
2220 |
||
2221 |
||
46729 | 2222 |
// Update class loader data dictionary - done after check_constraint and add_to_hierachy |
1 | 2223 |
// have been called. |
2224 |
void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash, |
|
2225 |
int p_index, unsigned int p_hash, |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2226 |
InstanceKlass* k, |
1 | 2227 |
Handle class_loader, |
2228 |
TRAPS) { |
|
2229 |
// Compile_lock prevents systemDictionary updates during compilations |
|
2230 |
assert_locked_or_safepoint(Compile_lock); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2231 |
Symbol* name = k->name(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2232 |
ClassLoaderData *loader_data = class_loader_data(class_loader); |
1 | 2233 |
|
2234 |
{ |
|
46729 | 2235 |
MutexLocker mu1(SystemDictionary_lock, THREAD); |
1 | 2236 |
|
46729 | 2237 |
// See whether biased locking is enabled and if so set it for this |
2238 |
// klass. |
|
2239 |
// Note that this must be done past the last potential blocking |
|
2240 |
// point / safepoint. We enable biased locking lazily using a |
|
2241 |
// VM_Operation to iterate the SystemDictionary and installing the |
|
2242 |
// biasable mark word into each InstanceKlass's prototype header. |
|
2243 |
// To avoid race conditions where we accidentally miss enabling the |
|
2244 |
// optimization for one class in the process of being added to the |
|
2245 |
// dictionary, we must not safepoint after the test of |
|
2246 |
// BiasedLocking::enabled(). |
|
2247 |
if (UseBiasedLocking && BiasedLocking::enabled()) { |
|
2248 |
// Set biased locking bit for all loaded classes; it will be |
|
2249 |
// cleared if revocation occurs too often for this type |
|
2250 |
// NOTE that we must only do this when the class is initally |
|
2251 |
// defined, not each time it is referenced from a new class loader |
|
2252 |
if (k->class_loader() == class_loader()) { |
|
2253 |
k->set_prototype_header(markOopDesc::biased_locking_prototype()); |
|
2254 |
} |
|
1 | 2255 |
} |
2256 |
||
46729 | 2257 |
// Make a new dictionary entry. |
2258 |
Dictionary* dictionary = loader_data->dictionary(); |
|
2259 |
InstanceKlass* sd_check = find_class(d_index, d_hash, name, dictionary); |
|
2260 |
if (sd_check == NULL) { |
|
2261 |
dictionary->add_klass(d_index, d_hash, name, k); |
|
2262 |
notice_modification(); |
|
2263 |
} |
|
2264 |
#ifdef ASSERT |
|
2265 |
sd_check = find_class(d_index, d_hash, name, dictionary); |
|
2266 |
assert (sd_check != NULL, "should have entry in dictionary"); |
|
2267 |
// Note: there may be a placeholder entry: for circularity testing |
|
2268 |
// or for parallel defines |
|
2269 |
#endif |
|
1 | 2270 |
SystemDictionary_lock->notify_all(); |
2271 |
} |
|
2272 |
} |
|
2273 |
||
2274 |
||
8314
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2275 |
// Try to find a class name using the loader constraints. The |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2276 |
// loader constraints might know about a class that isn't fully loaded |
057b1c20fd7e
6354181: nsk.logging.stress.threads.scmhml001 fails assertion in "src/share/vm/oops/instanceKlass.cpp, 111"
never
parents:
8076
diff
changeset
|
2277 |
// yet and these will be ignored. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2278 |
Klass* SystemDictionary::find_constrained_instance_or_array_klass( |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2279 |
Symbol* class_name, Handle class_loader, TRAPS) { |
1 | 2280 |
|
2281 |
// First see if it has been loaded directly. |
|
2282 |
// Force the protection domain to be null. (This removes protection checks.) |
|
2283 |
Handle no_protection_domain; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2284 |
Klass* klass = find_instance_or_array_klass(class_name, class_loader, |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
2285 |
no_protection_domain, CHECK_NULL); |
1 | 2286 |
if (klass != NULL) |
2287 |
return klass; |
|
2288 |
||
2289 |
// Now look to see if it has been loaded elsewhere, and is subject to |
|
2290 |
// a loader constraint that would require this loader to return the |
|
2291 |
// klass that is already loaded. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2292 |
if (FieldType::is_array(class_name)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2293 |
// For array classes, their Klass*s are not kept in the |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2294 |
// constraint table. The element Klass*s are. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2295 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2296 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL)); |
1 | 2297 |
if (t != T_OBJECT) { |
2298 |
klass = Universe::typeArrayKlassObj(t); |
|
2299 |
} else { |
|
2300 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2301 |
klass = constraints()->find_constrained_klass(fd.object_key(), class_loader); |
1 | 2302 |
} |
5121 | 2303 |
// If element class already loaded, allocate array klass |
1 | 2304 |
if (klass != NULL) { |
14488 | 2305 |
klass = klass->array_klass_or_null(fd.dimension()); |
1 | 2306 |
} |
2307 |
} else { |
|
2308 |
MutexLocker mu(SystemDictionary_lock, THREAD); |
|
2309 |
// Non-array classes are easy: simply check the constraint table. |
|
2310 |
klass = constraints()->find_constrained_klass(class_name, class_loader); |
|
2311 |
} |
|
2312 |
||
2313 |
return klass; |
|
2314 |
} |
|
2315 |
||
2316 |
||
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2317 |
bool SystemDictionary::add_loader_constraint(Symbol* class_name, |
1 | 2318 |
Handle class_loader1, |
2319 |
Handle class_loader2, |
|
2320 |
Thread* THREAD) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2321 |
ClassLoaderData* loader_data1 = class_loader_data(class_loader1); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2322 |
ClassLoaderData* loader_data2 = class_loader_data(class_loader2); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2323 |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2324 |
Symbol* constraint_name = NULL; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2325 |
if (!FieldType::is_array(class_name)) { |
5121 | 2326 |
constraint_name = class_name; |
2327 |
} else { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2328 |
// For array classes, their Klass*s are not kept in the |
5121 | 2329 |
// constraint table. The element classes are. |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2330 |
FieldArrayInfo fd; |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2331 |
BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false)); |
5121 | 2332 |
// primitive types always pass |
2333 |
if (t != T_OBJECT) { |
|
2334 |
return true; |
|
2335 |
} else { |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2336 |
constraint_name = fd.object_key(); |
5121 | 2337 |
} |
2338 |
} |
|
1 | 2339 |
|
46729 | 2340 |
Dictionary* dictionary1 = loader_data1->dictionary(); |
2341 |
unsigned int d_hash1 = dictionary1->compute_hash(constraint_name); |
|
2342 |
int d_index1 = dictionary1->hash_to_index(d_hash1); |
|
1 | 2343 |
|
46729 | 2344 |
Dictionary* dictionary2 = loader_data2->dictionary(); |
2345 |
unsigned int d_hash2 = dictionary2->compute_hash(constraint_name); |
|
2346 |
int d_index2 = dictionary2->hash_to_index(d_hash2); |
|
1 | 2347 |
|
46729 | 2348 |
{ |
2349 |
MutexLocker mu_s(SystemDictionary_lock, THREAD); |
|
2350 |
InstanceKlass* klass1 = find_class(d_index1, d_hash1, constraint_name, dictionary1); |
|
2351 |
InstanceKlass* klass2 = find_class(d_index2, d_hash2, constraint_name, dictionary2); |
|
2352 |
return constraints()->add_entry(constraint_name, klass1, class_loader1, |
|
2353 |
klass2, class_loader2); |
|
1 | 2354 |
} |
2355 |
} |
|
2356 |
||
2357 |
// Add entry to resolution error table to record the error when the first |
|
2358 |
// attempt to resolve a reference to a class has failed. |
|
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
2359 |
void SystemDictionary::add_resolution_error(const constantPoolHandle& pool, int which, |
24334
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2360 |
Symbol* error, Symbol* message) { |
1 | 2361 |
unsigned int hash = resolution_errors()->compute_hash(pool, which); |
2362 |
int index = resolution_errors()->hash_to_index(hash); |
|
2363 |
{ |
|
2364 |
MutexLocker ml(SystemDictionary_lock, Thread::current()); |
|
24334
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2365 |
resolution_errors()->add_entry(index, hash, pool, which, error, message); |
1 | 2366 |
} |
2367 |
} |
|
2368 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2369 |
// Delete a resolution error for RedefineClasses for a constant pool is going away |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2370 |
void SystemDictionary::delete_resolution_error(ConstantPool* pool) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2371 |
resolution_errors()->delete_entry(pool); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2372 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2373 |
|
1 | 2374 |
// Lookup resolution error table. Returns error if found, otherwise NULL. |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33198
diff
changeset
|
2375 |
Symbol* SystemDictionary::find_resolution_error(const constantPoolHandle& pool, int which, |
24334
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2376 |
Symbol** message) { |
1 | 2377 |
unsigned int hash = resolution_errors()->compute_hash(pool, which); |
2378 |
int index = resolution_errors()->hash_to_index(hash); |
|
2379 |
{ |
|
2380 |
MutexLocker ml(SystemDictionary_lock, Thread::current()); |
|
2381 |
ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which); |
|
24334
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2382 |
if (entry != NULL) { |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2383 |
*message = entry->message(); |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2384 |
return entry->error(); |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2385 |
} else { |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2386 |
return NULL; |
36096f7271f4
8023697: failed class resolution reports different class name in detail message for the first and subsequent times
coleenp
parents:
23872
diff
changeset
|
2387 |
} |
1 | 2388 |
} |
2389 |
} |
|
2390 |
||
2391 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2392 |
// Signature constraints ensure that callers and callees agree about |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2393 |
// the meaning of type names in their signatures. This routine is the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2394 |
// intake for constraints. It collects them from several places: |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2395 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2396 |
// * LinkResolver::resolve_method (if check_access is true) requires |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2397 |
// that the resolving class (the caller) and the defining class of |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2398 |
// the resolved method (the callee) agree on each type in the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2399 |
// method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2400 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2401 |
// * LinkResolver::resolve_interface_method performs exactly the same |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2402 |
// checks. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2403 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2404 |
// * LinkResolver::resolve_field requires that the constant pool |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2405 |
// attempting to link to a field agree with the field's defining |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2406 |
// class about the type of the field signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2407 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2408 |
// * klassVtable::initialize_vtable requires that, when a class |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2409 |
// overrides a vtable entry allocated by a superclass, that the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2410 |
// overriding method (i.e., the callee) agree with the superclass |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2411 |
// on each type in the method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2412 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2413 |
// * klassItable::initialize_itable requires that, when a class fills |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2414 |
// in its itables, for each non-abstract method installed in an |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2415 |
// itable, the method (i.e., the callee) agree with the interface |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2416 |
// on each type in the method's signature. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2417 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2418 |
// All those methods have a boolean (check_access, checkconstraints) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2419 |
// which turns off the checks. This is used from specialized contexts |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2420 |
// such as bootstrapping, dumping, and debugging. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2421 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2422 |
// No direct constraint is placed between the class and its |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2423 |
// supertypes. Constraints are only placed along linked relations |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2424 |
// between callers and callees. When a method overrides or implements |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2425 |
// an abstract method in a supertype (superclass or interface), the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2426 |
// constraints are placed as if the supertype were the caller to the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2427 |
// overriding method. (This works well, since callers to the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2428 |
// supertype have already established agreement between themselves and |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2429 |
// the supertype.) As a result of all this, a class can disagree with |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2430 |
// its supertype about the meaning of a type name, as long as that |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2431 |
// class neither calls a relevant method of the supertype, nor is |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2432 |
// called (perhaps via an override) from the supertype. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2433 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2434 |
// |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2435 |
// SystemDictionary::check_signature_loaders(sig, l1, l2) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2105
diff
changeset
|
2436 |
// |
1 | 2437 |
// Make sure all class components (including arrays) in the given |
2438 |
// signature will be resolved to the same class in both loaders. |
|
2439 |
// Returns the name of the type that failed a loader constraint check, or |
|
16591
73047b0eb568
8009731: Confusing error message for loader constraint violation
acorn
parents:
16352
diff
changeset
|
2440 |
// NULL if no constraint failed. No exception except OOME is thrown. |
5121 | 2441 |
// Arrays are not added to the loader constraint table, their elements are. |
16591
73047b0eb568
8009731: Confusing error message for loader constraint violation
acorn
parents:
16352
diff
changeset
|
2442 |
Symbol* SystemDictionary::check_signature_loaders(Symbol* signature, |
1 | 2443 |
Handle loader1, Handle loader2, |
2444 |
bool is_method, TRAPS) { |
|
2445 |
// Nothing to do if loaders are the same. |
|
2446 |
if (loader1() == loader2()) { |
|
2447 |
return NULL; |
|
2448 |
} |
|
2449 |
||
2450 |
SignatureStream sig_strm(signature, is_method); |
|
2451 |
while (!sig_strm.is_done()) { |
|
2452 |
if (sig_strm.is_object()) { |
|
16591
73047b0eb568
8009731: Confusing error message for loader constraint violation
acorn
parents:
16352
diff
changeset
|
2453 |
Symbol* sig = sig_strm.as_symbol(CHECK_NULL); |
1 | 2454 |
if (!add_loader_constraint(sig, loader1, loader2, THREAD)) { |
16591
73047b0eb568
8009731: Confusing error message for loader constraint violation
acorn
parents:
16352
diff
changeset
|
2455 |
return sig; |
1 | 2456 |
} |
2457 |
} |
|
2458 |
sig_strm.next(); |
|
2459 |
} |
|
2460 |
return NULL; |
|
2461 |
} |
|
2462 |
||
2463 |
||
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2464 |
methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2465 |
Symbol* signature, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2466 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2467 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2468 |
assert(MethodHandles::is_signature_polymorphic(iid) && |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2469 |
MethodHandles::is_signature_polymorphic_intrinsic(iid) && |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2470 |
iid != vmIntrinsics::_invokeGeneric, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32349
diff
changeset
|
2471 |
"must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2472 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2473 |
unsigned int hash = invoke_method_table()->compute_hash(signature, iid); |
2534 | 2474 |
int index = invoke_method_table()->hash_to_index(hash); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2475 |
SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2476 |
methodHandle m; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2477 |
if (spe == NULL || spe->method() == NULL) { |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2478 |
spe = NULL; |
2534 | 2479 |
// Must create lots of stuff here, but outside of the SystemDictionary lock. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2480 |
m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty)); |
26911
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2481 |
if (!Arguments::is_interpreter_only()) { |
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2482 |
// Generate a compiled form of the MH intrinsic. |
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2483 |
AdapterHandlerLibrary::create_native_wrapper(m); |
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2484 |
// Check if have the compiled code. |
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2485 |
if (!m->has_compiled_code()) { |
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2486 |
THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(), |
34213
3f99eccd6ea3
8067939: make Out of space in CodeCache messages consistent
tpivovarova
parents:
33612
diff
changeset
|
2487 |
"Out of space in CodeCache for method handle intrinsic", empty); |
26911
8f2c7a83220f
8058536: java/lang/instrument/NativeMethodPrefixAgent.java fails due to VirtualMachineError: out of space in CodeCache for method handle intrinsic
iveresov
parents:
26585
diff
changeset
|
2488 |
} |
26585
2048b8d90c91
8058092: Test vm/mlvm/meth/stress/compiler/deoptimize. Assert in src/share/vm/classfile/systemDictionary.cpp: MH intrinsic invariant
iveresov
parents:
26583
diff
changeset
|
2489 |
} |
2534 | 2490 |
// Now grab the lock. We might have to throw away the new method, |
2491 |
// if a racing thread has managed to install one at the same time. |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2492 |
{ |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2493 |
MutexLocker ml(SystemDictionary_lock, THREAD); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2494 |
spe = invoke_method_table()->find_entry(index, hash, signature, iid); |
2534 | 2495 |
if (spe == NULL) |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2496 |
spe = invoke_method_table()->add_entry(index, hash, signature, iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2497 |
if (spe->method() == NULL) |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2498 |
spe->set_method(m()); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2499 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2500 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2501 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2502 |
assert(spe != NULL && spe->method() != NULL, ""); |
26585
2048b8d90c91
8058092: Test vm/mlvm/meth/stress/compiler/deoptimize. Assert in src/share/vm/classfile/systemDictionary.cpp: MH intrinsic invariant
iveresov
parents:
26583
diff
changeset
|
2503 |
assert(Arguments::is_interpreter_only() || (spe->method()->has_compiled_code() && |
26580
8cca7fbe77b8
8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents:
26181
diff
changeset
|
2504 |
spe->method()->code()->entry_point() == spe->method()->from_compiled_entry()), |
8cca7fbe77b8
8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running
iveresov
parents:
26181
diff
changeset
|
2505 |
"MH intrinsic invariant"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2506 |
return spe->method(); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2507 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2508 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2509 |
// Helper for unpacking the return value from linkMethod and linkCallSite. |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2510 |
static methodHandle unpack_method_and_appendix(Handle mname, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2511 |
Klass* accessing_klass, |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2512 |
objArrayHandle appendix_box, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2513 |
Handle* appendix_result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2514 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2515 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2516 |
if (mname.not_null()) { |
46505
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
2517 |
Method* m = java_lang_invoke_MemberName::vmtarget(mname()); |
fd4bc78630b1
8174749: Use hash table/oops for MemberName table
coleenp
parents:
46444
diff
changeset
|
2518 |
if (m != NULL) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2519 |
oop appendix = appendix_box->obj_at(0); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2520 |
if (TraceMethodHandles) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2521 |
#ifndef PRODUCT |
35543
0961315f4016
8140659: C1: invokedynamic call patching violates JVMS-6.5.invokedynamic
vlivanov
parents:
34666
diff
changeset
|
2522 |
ttyLocker ttyl; |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24352
diff
changeset
|
2523 |
tty->print("Linked method=" INTPTR_FORMAT ": ", p2i(m)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2524 |
m->print(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2525 |
if (appendix != NULL) { tty->print("appendix = "); appendix->print(); } |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2526 |
tty->cr(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2527 |
#endif //PRODUCT |
9630
d6419e4395e3
6939861: JVM should handle more conversion operations
never
parents:
9172
diff
changeset
|
2528 |
} |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2529 |
(*appendix_result) = Handle(THREAD, appendix); |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2530 |
// the target is stored in the cpCache and if a reference to this |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2531 |
// MethodName is dropped we need a way to make sure the |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2532 |
// class_loader containing this method is kept alive. |
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2533 |
// FIXME: the appendix might also preserve this dependency. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2534 |
ClassLoaderData* this_key = accessing_klass->class_loader_data(); |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2535 |
this_key->record_dependency(m->method_holder(), CHECK_NULL); // Can throw OOM |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2536 |
return methodHandle(THREAD, m); |
2534 | 2537 |
} |
2538 |
} |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2539 |
THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2540 |
return empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2541 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2542 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2543 |
methodHandle SystemDictionary::find_method_handle_invoker(Klass* klass, |
36819 | 2544 |
Symbol* name, |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2545 |
Symbol* signature, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2546 |
Klass* accessing_klass, |
13929
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2547 |
Handle *appendix_result, |
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2548 |
Handle *method_type_result, |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2549 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2550 |
methodHandle empty; |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
2551 |
assert(THREAD->can_call_java() ,""); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2552 |
Handle method_type = |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2553 |
SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2554 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2555 |
int ref_kind = JVM_REF_invokeVirtual; |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2556 |
oop name_oop = StringTable::intern(name, CHECK_(empty)); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2557 |
Handle name_str (THREAD, name_oop); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2558 |
objArrayHandle appendix_box = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2559 |
assert(appendix_box->obj_at(0) == NULL, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2560 |
|
21103
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2561 |
// This should not happen. JDK code should take care of that. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2562 |
if (accessing_klass == NULL || method_type.is_null()) { |
21103
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2563 |
THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokehandle", empty); |
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2564 |
} |
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2565 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2566 |
// call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2567 |
JavaCallArguments args; |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2568 |
args.push_oop(Handle(THREAD, accessing_klass->java_mirror())); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2569 |
args.push_int(ref_kind); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2570 |
args.push_oop(Handle(THREAD, klass->java_mirror())); |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2571 |
args.push_oop(name_str); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2572 |
args.push_oop(method_type); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2573 |
args.push_oop(appendix_box); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2574 |
JavaValue result(T_OBJECT); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2575 |
JavaCalls::call_static(&result, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2576 |
SystemDictionary::MethodHandleNatives_klass(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2577 |
vmSymbols::linkMethod_name(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2578 |
vmSymbols::linkMethod_signature(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2579 |
&args, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2580 |
Handle mname(THREAD, (oop) result.get_jobject()); |
13929
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2581 |
(*method_type_result) = method_type; |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2582 |
return unpack_method_and_appendix(mname, accessing_klass, appendix_box, appendix_result, THREAD); |
2534 | 2583 |
} |
2584 |
||
31638 | 2585 |
// Decide if we can globally cache a lookup of this class, to be returned to any client that asks. |
2586 |
// We must ensure that all class loaders everywhere will reach this class, for any client. |
|
2587 |
// This is a safe bet for public classes in java.lang, such as Object and String. |
|
2588 |
// We also include public classes in java.lang.invoke, because they appear frequently in system-level method types. |
|
2589 |
// Out of an abundance of caution, we do not include any other classes, not even for packages like java.util. |
|
2590 |
static bool is_always_visible_class(oop mirror) { |
|
2591 |
Klass* klass = java_lang_Class::as_Klass(mirror); |
|
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2592 |
if (klass->is_objArray_klass()) { |
31638 | 2593 |
klass = ObjArrayKlass::cast(klass)->bottom_klass(); // check element type |
2594 |
} |
|
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2595 |
if (klass->is_typeArray_klass()) { |
31638 | 2596 |
return true; // primitive array |
2597 |
} |
|
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2598 |
assert(klass->is_instance_klass(), "%s", klass->external_name()); |
31638 | 2599 |
return klass->is_public() && |
2600 |
(InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::Object_klass()) || // java.lang |
|
2601 |
InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::MethodHandle_klass())); // java.lang.invoke |
|
2602 |
} |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2603 |
|
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2604 |
// Ask Java code to find or construct a java.lang.invoke.MethodType for the given |
2534 | 2605 |
// signature, as interpreted relative to the given class loader. |
2606 |
// Because of class loader constraints, all method handle usage must be |
|
2607 |
// consistent with this loader. |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2608 |
Handle SystemDictionary::find_method_handle_type(Symbol* signature, |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2609 |
Klass* accessing_klass, |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2610 |
TRAPS) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2611 |
Handle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2612 |
vmIntrinsics::ID null_iid = vmIntrinsics::_none; // distinct from all method handle invoker intrinsics |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2613 |
unsigned int hash = invoke_method_table()->compute_hash(signature, null_iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2614 |
int index = invoke_method_table()->hash_to_index(hash); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2615 |
SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2616 |
if (spe != NULL && spe->method_type() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2617 |
assert(java_lang_invoke_MethodType::is_instance(spe->method_type()), ""); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2618 |
return Handle(THREAD, spe->method_type()); |
33160
c59f1676d27e
8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents:
32349
diff
changeset
|
2619 |
} else if (!THREAD->can_call_java()) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2620 |
warning("SystemDictionary::find_method_handle_type called from compiler thread"); // FIXME |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2621 |
return Handle(); // do not attempt from within compiler, unless it was cached |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2622 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2623 |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2624 |
Handle class_loader, protection_domain; |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2625 |
if (accessing_klass != NULL) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2626 |
class_loader = Handle(THREAD, accessing_klass->class_loader()); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2627 |
protection_domain = Handle(THREAD, accessing_klass->protection_domain()); |
31638 | 2628 |
} |
2629 |
bool can_be_cached = true; |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2630 |
int npts = ArgumentCount(signature).size(); |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2631 |
objArrayHandle pts = oopFactory::new_objArray_handle(SystemDictionary::Class_klass(), npts, CHECK_(empty)); |
2534 | 2632 |
int arg = 0; |
31638 | 2633 |
Handle rt; // the return type from the signature |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2634 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2635 |
for (SignatureStream ss(signature); !ss.is_done(); ss.next()) { |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2636 |
oop mirror = NULL; |
31638 | 2637 |
if (can_be_cached) { |
2638 |
// Use neutral class loader to lookup candidate classes to be placed in the cache. |
|
2639 |
mirror = ss.as_java_mirror(Handle(), Handle(), |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2640 |
SignatureStream::ReturnNull, CHECK_(empty)); |
31638 | 2641 |
if (mirror == NULL || (ss.is_object() && !is_always_visible_class(mirror))) { |
2642 |
// Fall back to accessing_klass context. |
|
2643 |
can_be_cached = false; |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2644 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2645 |
} |
31638 | 2646 |
if (!can_be_cached) { |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2647 |
// Resolve, throwing a real error if it doesn't work. |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2648 |
mirror = ss.as_java_mirror(class_loader, protection_domain, |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2649 |
SignatureStream::NCDFError, CHECK_(empty)); |
2534 | 2650 |
} |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
32349
diff
changeset
|
2651 |
assert(!oopDesc::is_null(mirror), "%s", ss.as_symbol(THREAD)->as_C_string()); |
2534 | 2652 |
if (ss.at_return_type()) |
2653 |
rt = Handle(THREAD, mirror); |
|
2654 |
else |
|
2655 |
pts->obj_at_put(arg++, mirror); |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2656 |
|
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2657 |
// Check accessibility. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2658 |
if (ss.is_object() && accessing_klass != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2659 |
Klass* sel_klass = java_lang_Class::as_Klass(mirror); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2660 |
mirror = NULL; // safety |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2661 |
// Emulate ConstantPool::verify_constant_pool_resolve. |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2662 |
if (sel_klass->is_objArray_klass()) |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13753
diff
changeset
|
2663 |
sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass(); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2664 |
if (sel_klass->is_instance_klass()) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2665 |
LinkResolver::check_klass_accessability(accessing_klass, sel_klass, CHECK_(empty)); |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2666 |
} |
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2667 |
} |
2534 | 2668 |
} |
2669 |
assert(arg == npts, ""); |
|
2670 |
||
42074
c069e5e285cb
8166974: invokedynamic implementation should not wrap Errors
psandoz
parents:
41739
diff
changeset
|
2671 |
// call java.lang.invoke.MethodHandleNatives::findMethodHandleType(Class rt, Class[] pts) -> MethodType |
2534 | 2672 |
JavaCallArguments args(Handle(THREAD, rt())); |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2673 |
args.push_oop(pts); |
2534 | 2674 |
JavaValue result(T_OBJECT); |
2675 |
JavaCalls::call_static(&result, |
|
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2676 |
SystemDictionary::MethodHandleNatives_klass(), |
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2677 |
vmSymbols::findMethodHandleType_name(), |
9116 | 2678 |
vmSymbols::findMethodHandleType_signature(), |
2534 | 2679 |
&args, CHECK_(empty)); |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2680 |
Handle method_type(THREAD, (oop) result.get_jobject()); |
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2681 |
|
31638 | 2682 |
if (can_be_cached) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2683 |
// We can cache this MethodType inside the JVM. |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2684 |
MutexLocker ml(SystemDictionary_lock, THREAD); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2685 |
spe = invoke_method_table()->find_entry(index, hash, signature, null_iid); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2686 |
if (spe == NULL) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2687 |
spe = invoke_method_table()->add_entry(index, hash, signature, null_iid); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2688 |
if (spe->method_type() == NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2689 |
spe->set_method_type(method_type()); |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2690 |
} |
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2691 |
} |
5421
e294db54fc0d
6939196: method handle signatures off the boot class path get linkage errors
jrose
parents:
5420
diff
changeset
|
2692 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2693 |
// report back to the caller with the MethodType |
6463
f4362c8da849
6939224: MethodHandle.invokeGeneric needs to perform the correct set of conversions
jrose
parents:
6062
diff
changeset
|
2694 |
return method_type; |
2534 | 2695 |
} |
2696 |
||
5882 | 2697 |
// Ask Java code to find or construct a method handle constant. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2698 |
Handle SystemDictionary::link_method_handle_constant(Klass* caller, |
5882 | 2699 |
int ref_kind, //e.g., JVM_REF_invokeVirtual |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2700 |
Klass* callee, |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2701 |
Symbol* name_sym, |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2702 |
Symbol* signature, |
5882 | 2703 |
TRAPS) { |
2704 |
Handle empty; |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2705 |
Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty)); |
5882 | 2706 |
Handle type; |
2707 |
if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') { |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2708 |
type = find_method_handle_type(signature, caller, CHECK_(empty)); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2709 |
} else if (caller == NULL) { |
21103
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2710 |
// This should not happen. JDK code should take care of that. |
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2711 |
THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad MH constant", empty); |
5882 | 2712 |
} else { |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2713 |
ResourceMark rm(THREAD); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7426
diff
changeset
|
2714 |
SignatureStream ss(signature, false); |
5882 | 2715 |
if (!ss.is_done()) { |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2716 |
oop mirror = ss.as_java_mirror(Handle(THREAD, caller->class_loader()), |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2717 |
Handle(THREAD, caller->protection_domain()), |
5882 | 2718 |
SignatureStream::NCDFError, CHECK_(empty)); |
2719 |
type = Handle(THREAD, mirror); |
|
2720 |
ss.next(); |
|
2721 |
if (!ss.is_done()) type = Handle(); // error! |
|
2722 |
} |
|
2723 |
} |
|
2724 |
if (type.is_null()) { |
|
2725 |
THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad signature", empty); |
|
2726 |
} |
|
2727 |
||
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2728 |
// call java.lang.invoke.MethodHandleNatives::linkMethodHandleConstant(Class caller, int refKind, Class callee, String name, Object type) -> MethodHandle |
5882 | 2729 |
JavaCallArguments args; |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2730 |
args.push_oop(Handle(THREAD, caller->java_mirror())); // the referring class |
5882 | 2731 |
args.push_int(ref_kind); |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2732 |
args.push_oop(Handle(THREAD, callee->java_mirror())); // the target class |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2733 |
args.push_oop(name); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2734 |
args.push_oop(type); |
5882 | 2735 |
JavaValue result(T_OBJECT); |
2736 |
JavaCalls::call_static(&result, |
|
2737 |
SystemDictionary::MethodHandleNatives_klass(), |
|
2738 |
vmSymbols::linkMethodHandleConstant_name(), |
|
9116 | 2739 |
vmSymbols::linkMethodHandleConstant_signature(), |
5882 | 2740 |
&args, CHECK_(empty)); |
2741 |
return Handle(THREAD, (oop) result.get_jobject()); |
|
2742 |
} |
|
2534 | 2743 |
|
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8675
diff
changeset
|
2744 |
// Ask Java code to find or construct a java.lang.invoke.CallSite for the given |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2745 |
// name and signature, as interpreted relative to the given class loader. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2746 |
methodHandle SystemDictionary::find_dynamic_call_site_invoker(Klass* caller, |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2747 |
Handle bootstrap_specifier, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2748 |
Symbol* name, |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2749 |
Symbol* type, |
13929
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2750 |
Handle *appendix_result, |
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2751 |
Handle *method_type_result, |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2752 |
TRAPS) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2753 |
methodHandle empty; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2754 |
Handle bsm, info; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2755 |
if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2756 |
bsm = bootstrap_specifier; |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2757 |
} else { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2758 |
assert(bootstrap_specifier->is_objArray(), ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2759 |
objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier()); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2760 |
int len = args->length(); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2761 |
assert(len >= 1, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2762 |
bsm = Handle(THREAD, args->obj_at(0)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2763 |
if (len > 1) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2764 |
objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2765 |
for (int i = 1; i < len; i++) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2766 |
args1->obj_at_put(i-1, args->obj_at(i)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2767 |
info = Handle(THREAD, args1); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2768 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2769 |
} |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2770 |
guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()), |
6062
bab93afe9df7
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
5882
diff
changeset
|
2771 |
"caller must supply a valid BSM"); |
bab93afe9df7
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
5882
diff
changeset
|
2772 |
|
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2773 |
Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2774 |
Handle method_type = find_method_handle_type(type, caller, CHECK_(empty)); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2775 |
|
21103
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2776 |
// This should not happen. JDK code should take care of that. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2777 |
if (caller == NULL || method_type.is_null()) { |
21103
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2778 |
THROW_MSG_(vmSymbols::java_lang_InternalError(), "bad invokedynamic", empty); |
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2779 |
} |
1c85309b5895
8026502: java/lang/invoke/MethodHandleConstants.java fails on all platforms
twisti
parents:
20405
diff
changeset
|
2780 |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2781 |
objArrayHandle appendix_box = oopFactory::new_objArray_handle(SystemDictionary::Object_klass(), 1, CHECK_(empty)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2782 |
assert(appendix_box->obj_at(0) == NULL, ""); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2783 |
|
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2784 |
// call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix) |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2785 |
JavaCallArguments args; |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2786 |
args.push_oop(Handle(THREAD, caller->java_mirror())); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2787 |
args.push_oop(bsm); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2788 |
args.push_oop(method_name); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2789 |
args.push_oop(method_type); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42876
diff
changeset
|
2790 |
args.push_oop(info); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2791 |
args.push_oop(appendix_box); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2792 |
JavaValue result(T_OBJECT); |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2793 |
JavaCalls::call_static(&result, |
5420
586d3988e72b
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
5124
diff
changeset
|
2794 |
SystemDictionary::MethodHandleNatives_klass(), |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2795 |
vmSymbols::linkCallSite_name(), |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2796 |
vmSymbols::linkCallSite_signature(), |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2797 |
&args, CHECK_(empty)); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13286
diff
changeset
|
2798 |
Handle mname(THREAD, (oop) result.get_jobject()); |
13929
8da0dc50a6e4
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
13753
diff
changeset
|
2799 |
(*method_type_result) = method_type; |
14588
8ec26d2d9339
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
14488
diff
changeset
|
2800 |
return unpack_method_and_appendix(mname, caller, appendix_box, appendix_result, THREAD); |
2570
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2801 |
} |
ecc7862946d4
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
2534
diff
changeset
|
2802 |
|
46729 | 2803 |
// Protection domain cache table handling |
2804 |
||
2805 |
ProtectionDomainCacheEntry* SystemDictionary::cache_get(Handle protection_domain) { |
|
2806 |
return _pd_cache_table->get(protection_domain); |
|
2807 |
} |
|
2808 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2809 |
void SystemDictionary::reorder_dictionary_for_sharing() { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2810 |
ClassLoaderData::the_null_class_loader_data()->dictionary()->reorder_dictionary_for_sharing(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2811 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2812 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2813 |
size_t SystemDictionary::count_bytes_for_buckets() { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2814 |
return ClassLoaderData::the_null_class_loader_data()->dictionary()->count_bytes_for_buckets(); |
1 | 2815 |
} |
2816 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2817 |
size_t SystemDictionary::count_bytes_for_table() { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2818 |
return ClassLoaderData::the_null_class_loader_data()->dictionary()->count_bytes_for_table(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2819 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2820 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2821 |
void SystemDictionary::copy_buckets(char* top, char* end) { |
46729 | 2822 |
ClassLoaderData::the_null_class_loader_data()->dictionary()->copy_buckets(top, end); |
1 | 2823 |
} |
2824 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
2825 |
void SystemDictionary::copy_table(char* top, char* end) { |
46729 | 2826 |
ClassLoaderData::the_null_class_loader_data()->dictionary()->copy_table(top, end); |
1 | 2827 |
} |
2828 |
||
2829 |
// ---------------------------------------------------------------------------- |
|
46742 | 2830 |
void SystemDictionary::print_shared(outputStream *st) { |
2831 |
shared_dictionary()->print_on(st); |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25492
diff
changeset
|
2832 |
} |
1 | 2833 |
|
46742 | 2834 |
void SystemDictionary::print_on(outputStream *st) { |
46729 | 2835 |
if (shared_dictionary() != NULL) { |
46747
7b6570052b58
8130072: Add a flag to print out statistics for both system dictionary and shared dictionary
coleenp
parents:
46746
diff
changeset
|
2836 |
st->print_cr("Shared Dictionary"); |
46742 | 2837 |
shared_dictionary()->print_on(st); |
46747
7b6570052b58
8130072: Add a flag to print out statistics for both system dictionary and shared dictionary
coleenp
parents:
46746
diff
changeset
|
2838 |
st->cr(); |
46729 | 2839 |
} |
2840 |
||
2841 |
GCMutexLocker mu(SystemDictionary_lock); |
|
2842 |
||
46742 | 2843 |
ClassLoaderDataGraph::print_dictionary(st); |
1 | 2844 |
|
2845 |
// Placeholders |
|
46742 | 2846 |
placeholders()->print_on(st); |
2847 |
st->cr(); |
|
1 | 2848 |
|
2849 |
// loader constraints - print under SD_lock |
|
46742 | 2850 |
constraints()->print_on(st); |
2851 |
st->cr(); |
|
2852 |
||
2853 |
_pd_cache_table->print_on(st); |
|
2854 |
st->cr(); |
|
1 | 2855 |
} |
2856 |
||
2857 |
void SystemDictionary::verify() { |
|
2858 |
guarantee(constraints() != NULL, |
|
2859 |
"Verify of loader constraints failed"); |
|
46729 | 2860 |
guarantee(placeholders()->number_of_entries() >= 0, |
2861 |
"Verify of placeholders failed"); |
|
2862 |
||
2863 |
GCMutexLocker mu(SystemDictionary_lock); |
|
1 | 2864 |
|
2865 |
// Verify dictionary |
|
46729 | 2866 |
ClassLoaderDataGraph::verify_dictionary(); |
1 | 2867 |
|
2868 |
placeholders()->verify(); |
|
2869 |
||
2870 |
// Verify constraint table |
|
2871 |
guarantee(constraints() != NULL, "Verify of loader constraints failed"); |
|
46729 | 2872 |
constraints()->verify(placeholders()); |
2873 |
||
2874 |
_pd_cache_table->verify(); |
|
1 | 2875 |
} |
2876 |
||
46742 | 2877 |
void SystemDictionary::dump(outputStream *st, bool verbose) { |
2878 |
assert_locked_or_safepoint(SystemDictionary_lock); |
|
2879 |
if (verbose) { |
|
2880 |
print_on(st); |
|
2881 |
} else { |
|
46747
7b6570052b58
8130072: Add a flag to print out statistics for both system dictionary and shared dictionary
coleenp
parents:
46746
diff
changeset
|
2882 |
if (shared_dictionary() != NULL) { |
7b6570052b58
8130072: Add a flag to print out statistics for both system dictionary and shared dictionary
coleenp
parents:
46746
diff
changeset
|
2883 |
shared_dictionary()->print_table_statistics(st, "Shared Dictionary"); |
7b6570052b58
8130072: Add a flag to print out statistics for both system dictionary and shared dictionary
coleenp
parents:
46746
diff
changeset
|
2884 |
} |
46742 | 2885 |
ClassLoaderDataGraph::print_dictionary_statistics(st); |
2886 |
placeholders()->print_table_statistics(st, "Placeholder Table"); |
|
2887 |
constraints()->print_table_statistics(st, "LoaderConstraints Table"); |
|
2888 |
_pd_cache_table->print_table_statistics(st, "ProtectionDomainCache Table"); |
|
2889 |
} |
|
2890 |
} |
|
2891 |
||
2892 |
// Utility for dumping dictionaries. |
|
2893 |
SystemDictionaryDCmd::SystemDictionaryDCmd(outputStream* output, bool heap) : |
|
2894 |
DCmdWithParser(output, heap), |
|
2895 |
_verbose("-verbose", "Dump the content of each dictionary entry for all class loaders", |
|
2896 |
"BOOLEAN", false, "false") { |
|
2897 |
_dcmdparser.add_dcmd_option(&_verbose); |
|
2898 |
} |
|
2899 |
||
2900 |
void SystemDictionaryDCmd::execute(DCmdSource source, TRAPS) { |
|
2901 |
VM_DumpHashtable dumper(output(), VM_DumpHashtable::DumpSysDict, |
|
2902 |
_verbose.value()); |
|
2903 |
VMThread::execute(&dumper); |
|
2904 |
} |
|
2905 |
||
2906 |
int SystemDictionaryDCmd::num_arguments() { |
|
2907 |
ResourceMark rm; |
|
2908 |
SystemDictionaryDCmd* dcmd = new SystemDictionaryDCmd(NULL, false); |
|
2909 |
if (dcmd != NULL) { |
|
2910 |
DCmdMark mark(dcmd); |
|
2911 |
return dcmd->_dcmdparser.num_arguments(); |
|
2912 |
} else { |
|
2913 |
return 0; |
|
2914 |
} |
|
2915 |
} |
|
2916 |
||
2917 |
||
34666 | 2918 |
// caller needs ResourceMark |
2919 |
const char* SystemDictionary::loader_name(const oop loader) { |
|
2920 |
return ((loader) == NULL ? "<bootloader>" : |
|
42575
bd1618170c93
8165550: Add class loader names to ClassCastException message
rprotacio
parents:
42074
diff
changeset
|
2921 |
InstanceKlass::cast((loader)->klass())->name()->as_C_string()); |
18025 | 2922 |
} |
2923 |
||
34666 | 2924 |
// caller needs ResourceMark |
2925 |
const char* SystemDictionary::loader_name(const ClassLoaderData* loader_data) { |
|
2926 |
return (loader_data->class_loader() == NULL ? "<bootloader>" : |
|
42575
bd1618170c93
8165550: Add class loader names to ClassCastException message
rprotacio
parents:
42074
diff
changeset
|
2927 |
SystemDictionary::loader_name(loader_data->class_loader())); |
34666 | 2928 |
} |