annotate src/share/vm/classfile/systemDictionary.cpp @ 3762:5c0a3c1858b1

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