Mercurial > hg > truffle
annotate src/share/vm/interpreter/linkResolver.cpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | f6b0eb4e44cf |
| children | 4735d2c84362 77443715ec55 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1508
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "classfile/vmSymbols.hpp" | |
| 28 #include "compiler/compileBroker.hpp" | |
| 29 #include "gc_interface/collectedHeap.inline.hpp" | |
| 30 #include "interpreter/bytecode.hpp" | |
| 31 #include "interpreter/interpreterRuntime.hpp" | |
| 32 #include "interpreter/linkResolver.hpp" | |
| 33 #include "memory/resourceArea.hpp" | |
| 34 #include "memory/universe.inline.hpp" | |
| 35 #include "oops/instanceKlass.hpp" | |
| 36 #include "oops/objArrayOop.hpp" | |
| 37 #include "prims/methodHandles.hpp" | |
| 38 #include "prims/nativeLookup.hpp" | |
| 39 #include "runtime/compilationPolicy.hpp" | |
| 40 #include "runtime/fieldDescriptor.hpp" | |
| 41 #include "runtime/frame.inline.hpp" | |
| 42 #include "runtime/handles.inline.hpp" | |
| 43 #include "runtime/reflection.hpp" | |
| 44 #include "runtime/signature.hpp" | |
| 45 #include "runtime/vmThread.hpp" | |
| 46 #ifdef TARGET_OS_FAMILY_linux | |
| 47 # include "thread_linux.inline.hpp" | |
| 48 #endif | |
| 49 #ifdef TARGET_OS_FAMILY_solaris | |
| 50 # include "thread_solaris.inline.hpp" | |
| 51 #endif | |
| 52 #ifdef TARGET_OS_FAMILY_windows | |
| 53 # include "thread_windows.inline.hpp" | |
| 54 #endif | |
| 3960 | 55 #ifdef TARGET_OS_FAMILY_bsd |
| 56 # include "thread_bsd.inline.hpp" | |
| 57 #endif | |
| 0 | 58 |
| 59 //------------------------------------------------------------------------------------------------------------------------ | |
| 60 // Implementation of FieldAccessInfo | |
| 61 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
62 void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset, |
| 0 | 63 BasicType field_type, AccessFlags access_flags) { |
| 64 _klass = klass; | |
| 65 _name = name; | |
| 66 _field_index = field_index; | |
| 67 _field_offset = field_offset; | |
| 68 _field_type = field_type; | |
| 69 _access_flags = access_flags; | |
| 70 } | |
| 71 | |
| 72 | |
| 73 //------------------------------------------------------------------------------------------------------------------------ | |
| 74 // Implementation of CallInfo | |
| 75 | |
| 76 | |
| 77 void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
78 int vtable_index = Method::nonvirtual_vtable_index; |
| 0 | 79 set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK); |
| 80 } | |
| 81 | |
| 82 | |
| 83 void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, TRAPS) { | |
| 84 // This is only called for interface methods. If the resolved_method | |
| 85 // comes from java/lang/Object, it can be the subject of a virtual call, so | |
| 86 // we should pick the vtable index from the resolved method. | |
| 87 // Other than that case, there is no valid vtable index to specify. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
88 int vtable_index = Method::invalid_vtable_index; |
| 1142 | 89 if (resolved_method->method_holder() == SystemDictionary::Object_klass()) { |
| 0 | 90 assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check"); |
| 91 vtable_index = resolved_method->vtable_index(); | |
| 92 } | |
| 93 set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK); | |
| 94 } | |
| 95 | |
| 96 void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
97 assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index"); |
| 0 | 98 set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
99 assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call"); |
| 0 | 100 } |
| 101 | |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
102 void CallInfo::set_handle(methodHandle resolved_method, Handle resolved_appendix, Handle resolved_method_type, TRAPS) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
103 if (resolved_method.is_null()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
104 THROW_MSG(vmSymbols::java_lang_InternalError(), "resolved method is null"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
105 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
106 KlassHandle resolved_klass = SystemDictionary::MethodHandle_klass(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
107 assert(resolved_method->intrinsic_id() == vmIntrinsics::_invokeBasic || |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
108 resolved_method->is_compiled_lambda_form(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
109 "linkMethod must return one of these"); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
110 int vtable_index = Method::nonvirtual_vtable_index; |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1552
diff
changeset
|
111 assert(resolved_method->vtable_index() == vtable_index, ""); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
112 set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK); |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
113 _resolved_appendix = resolved_appendix; |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
114 _resolved_method_type = resolved_method_type; |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1552
diff
changeset
|
115 } |
|
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1552
diff
changeset
|
116 |
| 0 | 117 void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) { |
| 118 assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond"); | |
| 119 _resolved_klass = resolved_klass; | |
| 120 _selected_klass = selected_klass; | |
| 121 _resolved_method = resolved_method; | |
| 122 _selected_method = selected_method; | |
| 123 _vtable_index = vtable_index; | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
124 _resolved_appendix = Handle(); |
| 1783 | 125 if (CompilationPolicy::must_be_compiled(selected_method)) { |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
126 // This path is unusual, mostly used by the '-Xcomp' stress test mode. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
127 |
| 1783 | 128 // Note: with several active threads, the must_be_compiled may be true |
| 129 // while can_be_compiled is false; remove assert | |
| 130 // assert(CompilationPolicy::can_be_compiled(selected_method), "cannot compile"); | |
| 0 | 131 if (THREAD->is_Compiler_thread()) { |
| 132 // don't force compilation, resolve was on behalf of compiler | |
| 133 return; | |
| 134 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
135 if (InstanceKlass::cast(selected_method->method_holder())->is_not_initialized()) { |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
136 // 'is_not_initialized' means not only '!is_initialized', but also that |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
137 // initialization has not been started yet ('!being_initialized') |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
138 // Do not force compilation of methods in uninitialized classes. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
139 // Note that doing this would throw an assert later, |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
140 // in CompileBroker::compile_method. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
141 // We sometimes use the link resolver to do reflective lookups |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
142 // even before classes are initialized. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
143 return; |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1059
diff
changeset
|
144 } |
| 0 | 145 CompileBroker::compile_method(selected_method, InvocationEntryBci, |
|
3837
43f9d800f276
7066339: Tiered: policy should make consistent decisions about osr levels
iveresov
parents:
3785
diff
changeset
|
146 CompilationPolicy::policy()->initial_compile_level(), |
| 1783 | 147 methodHandle(), 0, "must_be_compiled", CHECK); |
| 0 | 148 } |
| 149 } | |
| 150 | |
| 151 | |
| 152 //------------------------------------------------------------------------------------------------------------------------ | |
| 153 // Klass resolution | |
| 154 | |
| 155 void LinkResolver::check_klass_accessability(KlassHandle ref_klass, KlassHandle sel_klass, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
156 if (!Reflection::verify_class_access(ref_klass(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
157 sel_klass(), |
| 0 | 158 true)) { |
| 159 ResourceMark rm(THREAD); | |
| 160 Exceptions::fthrow( | |
| 161 THREAD_AND_LOCATION, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
162 vmSymbols::java_lang_IllegalAccessError(), |
| 0 | 163 "tried to access class %s from class %s", |
| 164 sel_klass->external_name(), | |
| 165 ref_klass->external_name() | |
| 166 ); | |
| 167 return; | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
172 Klass* result_oop = pool->klass_ref_at(index, CHECK); |
| 0 | 173 result = KlassHandle(THREAD, result_oop); |
| 174 } | |
| 175 | |
| 176 void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
177 Klass* result_oop = |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
178 ConstantPool::klass_ref_at_if_loaded_check(pool, index, CHECK); |
| 0 | 179 result = KlassHandle(THREAD, result_oop); |
| 180 } | |
| 181 | |
| 182 | |
| 183 //------------------------------------------------------------------------------------------------------------------------ | |
| 184 // Method resolution | |
| 185 // | |
| 186 // According to JVM spec. $5.4.3c & $5.4.3d | |
| 187 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
188 void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
189 Method* result_oop = klass->uncached_lookup_method(name, signature); |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2359
diff
changeset
|
190 if (EnableInvokeDynamic && result_oop != NULL) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
191 vmIntrinsics::ID iid = result_oop->intrinsic_id(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
192 if (MethodHandles::is_signature_polymorphic(iid)) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
193 // Do not link directly to these. The VM must produce a synthetic one using lookup_polymorphic_method. |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
194 return; |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
195 } |
|
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
196 } |
| 0 | 197 result = methodHandle(THREAD, result_oop); |
| 198 } | |
| 199 | |
| 200 // returns first instance method | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
201 void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
202 Method* result_oop = klass->uncached_lookup_method(name, signature); |
| 0 | 203 result = methodHandle(THREAD, result_oop); |
| 204 while (!result.is_null() && result->is_static()) { | |
| 205 klass = KlassHandle(THREAD, Klass::cast(result->method_holder())->super()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
206 result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature)); |
| 0 | 207 } |
| 208 } | |
| 209 | |
| 210 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
211 int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
| 0 | 212 ResourceMark rm(THREAD); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
213 klassVtable *vt = InstanceKlass::cast(klass())->vtable(); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
214 return vt->index_of_miranda(name, signature); |
| 0 | 215 } |
| 216 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
217 void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
218 InstanceKlass *ik = InstanceKlass::cast(klass()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 result = methodHandle(THREAD, ik->lookup_method_in_all_interfaces(name, signature)); |
| 0 | 220 } |
| 221 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
222 void LinkResolver::lookup_polymorphic_method(methodHandle& result, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
223 KlassHandle klass, Symbol* name, Symbol* full_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
224 KlassHandle current_klass, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
225 Handle *appendix_result_or_null, |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
226 Handle *method_type_result, |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
227 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
228 vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
229 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
230 tty->print_cr("lookup_polymorphic_method iid=%s %s.%s%s", |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
231 vmIntrinsics::name_at(iid), klass->external_name(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
232 name->as_C_string(), full_signature->as_C_string()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
233 } |
|
2416
38fea01eb669
6817525: turn on method handle functionality by default for JSR 292
twisti
parents:
2359
diff
changeset
|
234 if (EnableInvokeDynamic && |
|
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
235 klass() == SystemDictionary::MethodHandle_klass() && |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
236 iid != vmIntrinsics::_none) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
237 if (MethodHandles::is_signature_polymorphic_intrinsic(iid)) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
238 // Most of these do not need an up-call to Java to resolve, so can be done anywhere. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
239 // Do not erase last argument type (MemberName) if it is a static linkTo method. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
240 bool keep_last_arg = MethodHandles::is_signature_polymorphic_static(iid); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
241 TempNewSymbol basic_signature = |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
242 MethodHandles::lookup_basic_type_signature(full_signature, keep_last_arg, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
243 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
244 tty->print_cr("lookup_polymorphic_method %s %s => basic %s", |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
245 name->as_C_string(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
246 full_signature->as_C_string(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
247 basic_signature->as_C_string()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
248 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
249 result = SystemDictionary::find_method_handle_intrinsic(iid, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
250 basic_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
251 CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
252 if (result.not_null()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
253 assert(result->is_method_handle_intrinsic(), "MH.invokeBasic or MH.linkTo* intrinsic"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
254 assert(result->intrinsic_id() != vmIntrinsics::_invokeGeneric, "wrong place to find this"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
255 assert(basic_signature == result->signature(), "predict the result signature"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
256 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
257 tty->print("lookup_polymorphic_method => intrinsic "); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
258 result->print_on(tty); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
259 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
260 return; |
|
1660
083fde3b838e
6964498: JSR 292 invokedynamic sites need local bootstrap methods
jrose
parents:
1552
diff
changeset
|
261 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
262 } else if (iid == vmIntrinsics::_invokeGeneric |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
263 && !THREAD->is_Compiler_thread() |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
264 && appendix_result_or_null != NULL) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
265 // This is a method with type-checking semantics. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
266 // We will ask Java code to spin an adapter method for it. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
267 if (!MethodHandles::enabled()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
268 // Make sure the Java part of the runtime has been booted up. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
269 Klass* natives = SystemDictionary::MethodHandleNatives_klass(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
270 if (natives == NULL || InstanceKlass::cast(natives)->is_not_initialized()) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
271 SystemDictionary::resolve_or_fail(vmSymbols::java_lang_invoke_MethodHandleNatives(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
272 Handle(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
273 Handle(), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
274 true, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
275 CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
276 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
277 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
278 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
279 Handle appendix; |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
280 Handle method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
281 result = SystemDictionary::find_method_handle_invoker(name, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
282 full_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
283 current_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
284 &appendix, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
285 &method_type, |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
286 CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
287 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
288 tty->print("lookup_polymorphic_method => (via Java) "); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
289 result->print_on(tty); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
290 tty->print(" lookup_polymorphic_method => appendix = "); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
291 if (appendix.is_null()) tty->print_cr("(none)"); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
292 else appendix->print_on(tty); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
293 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
294 if (result.not_null()) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
295 #ifdef ASSERT |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
296 TempNewSymbol basic_signature = |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
297 MethodHandles::lookup_basic_type_signature(full_signature, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
298 int actual_size_of_params = result->size_of_parameters(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
299 int expected_size_of_params = ArgumentSizeComputer(basic_signature).size(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
300 // +1 for MethodHandle.this, +1 for trailing MethodType |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
301 if (!MethodHandles::is_signature_polymorphic_static(iid)) expected_size_of_params += 1; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
302 if (appendix.not_null()) expected_size_of_params += 1; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
303 if (actual_size_of_params != expected_size_of_params) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
304 tty->print_cr("*** basic_signature=%s", basic_signature->as_C_string()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
305 tty->print_cr("*** result for %s: ", vmIntrinsics::name_at(iid)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
306 result->print(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
307 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
308 assert(actual_size_of_params == expected_size_of_params, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
309 err_msg("%d != %d", actual_size_of_params, expected_size_of_params)); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
310 #endif //ASSERT |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
311 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
312 assert(appendix_result_or_null != NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
313 (*appendix_result_or_null) = appendix; |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
314 (*method_type_result) = method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
315 return; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
316 } |
| 710 | 317 } |
| 318 } | |
| 319 } | |
| 320 | |
| 0 | 321 void LinkResolver::check_method_accessability(KlassHandle ref_klass, |
| 322 KlassHandle resolved_klass, | |
| 323 KlassHandle sel_klass, | |
| 324 methodHandle sel_method, | |
| 325 TRAPS) { | |
| 326 | |
| 327 AccessFlags flags = sel_method->access_flags(); | |
| 328 | |
| 329 // Special case: arrays always override "clone". JVMS 2.15. | |
| 330 // If the resolved klass is an array class, and the declaring class | |
| 331 // is java.lang.Object and the method is "clone", set the flags | |
| 332 // to public. | |
| 333 // | |
| 334 // We'll check for the method name first, as that's most likely | |
| 335 // to be false (so we'll short-circuit out of these tests). | |
| 336 if (sel_method->name() == vmSymbols::clone_name() && | |
| 1142 | 337 sel_klass() == SystemDictionary::Object_klass() && |
| 0 | 338 resolved_klass->oop_is_array()) { |
| 339 // We need to change "protected" to "public". | |
| 340 assert(flags.is_protected(), "clone not protected?"); | |
| 341 jint new_flags = flags.as_int(); | |
| 342 new_flags = new_flags & (~JVM_ACC_PROTECTED); | |
| 343 new_flags = new_flags | JVM_ACC_PUBLIC; | |
| 344 flags.set_flags(new_flags); | |
| 345 } | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
346 // assert(extra_arg_result_or_null != NULL, "must be able to return extra argument"); |
| 0 | 347 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
348 if (!Reflection::verify_field_access(ref_klass(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
349 resolved_klass(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
350 sel_klass(), |
| 0 | 351 flags, |
| 352 true)) { | |
| 353 ResourceMark rm(THREAD); | |
| 354 Exceptions::fthrow( | |
| 355 THREAD_AND_LOCATION, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
356 vmSymbols::java_lang_IllegalAccessError(), |
| 0 | 357 "tried to access method %s.%s%s from class %s", |
| 358 sel_klass->external_name(), | |
| 359 sel_method->name()->as_C_string(), | |
| 360 sel_method->signature()->as_C_string(), | |
| 361 ref_klass->external_name() | |
| 362 ); | |
| 363 return; | |
| 364 } | |
| 365 } | |
| 366 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
367 void LinkResolver::resolve_method_statically(methodHandle& resolved_method, KlassHandle& resolved_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
368 Bytecodes::Code code, constantPoolHandle pool, int index, TRAPS) { |
| 0 | 369 |
| 370 // resolve klass | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
371 if (code == Bytecodes::_invokedynamic) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
372 resolved_klass = SystemDictionary::MethodHandle_klass(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
373 Symbol* method_name = vmSymbols::invoke_name(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
374 Symbol* method_signature = pool->signature_ref_at(index); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
375 KlassHandle current_klass(THREAD, pool->pool_holder()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
376 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
377 return; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
378 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
379 |
| 0 | 380 resolve_klass(resolved_klass, pool, index, CHECK); |
| 381 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
382 Symbol* method_name = pool->name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
383 Symbol* method_signature = pool->signature_ref_at(index); |
| 0 | 384 KlassHandle current_klass(THREAD, pool->pool_holder()); |
| 385 | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
386 if (pool->has_preresolution() |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
387 || (resolved_klass() == SystemDictionary::MethodHandle_klass() && |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
388 MethodHandles::is_signature_polymorphic_name(resolved_klass(), method_name))) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
389 Method* result_oop = ConstantPool::method_at_if_loaded(pool, index); |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
390 if (result_oop != NULL) { |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
391 resolved_method = methodHandle(THREAD, result_oop); |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
392 return; |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
393 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
394 } |
|
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
3744
diff
changeset
|
395 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
396 if (code == Bytecodes::_invokeinterface) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
397 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
398 } else { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
399 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
400 } |
| 0 | 401 } |
| 402 | |
| 403 void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
404 Symbol* method_name, Symbol* method_signature, |
| 0 | 405 KlassHandle current_klass, bool check_access, TRAPS) { |
| 406 | |
| 407 // 1. check if klass is not interface | |
| 408 if (resolved_klass->is_interface()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
409 ResourceMark rm(THREAD); |
| 0 | 410 char buf[200]; |
| 411 jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected", Klass::cast(resolved_klass())->external_name()); | |
| 412 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 413 } | |
| 414 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
415 Handle nested_exception; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
416 |
| 0 | 417 // 2. lookup method in resolved klass and its super klasses |
| 418 lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); | |
| 419 | |
| 420 if (resolved_method.is_null()) { // not found in the class hierarchy | |
| 421 // 3. lookup method in all the interfaces implemented by the resolved klass | |
| 422 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); | |
| 423 | |
| 424 if (resolved_method.is_null()) { | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
425 // JSR 292: see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
426 lookup_polymorphic_method(resolved_method, resolved_klass, method_name, method_signature, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
427 current_klass, (Handle*)NULL, (Handle*)NULL, THREAD); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
428 if (HAS_PENDING_EXCEPTION) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
429 nested_exception = Handle(THREAD, PENDING_EXCEPTION); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
430 CLEAR_PENDING_EXCEPTION; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
431 } |
| 710 | 432 } |
| 433 | |
| 434 if (resolved_method.is_null()) { | |
| 0 | 435 // 4. method lookup failed |
| 436 ResourceMark rm(THREAD); | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
437 THROW_MSG_CAUSE(vmSymbols::java_lang_NoSuchMethodError(), |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
438 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
439 method_name, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
440 method_signature), |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
441 nested_exception); |
| 0 | 442 } |
| 443 } | |
| 444 | |
| 445 // 5. check if method is concrete | |
| 446 if (resolved_method->is_abstract() && !resolved_klass->is_abstract()) { | |
| 447 ResourceMark rm(THREAD); | |
| 448 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
449 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
450 method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
451 method_signature)); |
| 0 | 452 } |
| 453 | |
| 454 // 6. access checks, access checking may be turned off when calling from within the VM. | |
| 455 if (check_access) { | |
| 456 assert(current_klass.not_null() , "current_klass should not be null"); | |
| 457 | |
| 458 // check if method can be accessed by the referring class | |
| 459 check_method_accessability(current_klass, | |
| 460 resolved_klass, | |
| 461 KlassHandle(THREAD, resolved_method->method_holder()), | |
| 462 resolved_method, | |
| 463 CHECK); | |
| 464 | |
| 465 // check loader constraints | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
466 Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
467 Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader()); |
| 0 | 468 { |
| 469 ResourceMark rm(THREAD); | |
| 470 char* failed_type_name = | |
| 471 SystemDictionary::check_signature_loaders(method_signature, loader, | |
| 472 class_loader, true, CHECK); | |
| 473 if (failed_type_name != NULL) { | |
| 474 const char* msg = "loader constraint violation: when resolving method" | |
| 475 " \"%s\" the class loader (instance of %s) of the current class, %s," | |
| 476 " and the class loader (instance of %s) for resolved class, %s, have" | |
| 477 " different Class objects for the type %s used in the signature"; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
478 char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); |
| 0 | 479 const char* loader1 = SystemDictionary::loader_name(loader()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
480 char* current = InstanceKlass::cast(current_klass())->name()->as_C_string(); |
| 0 | 481 const char* loader2 = SystemDictionary::loader_name(class_loader()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
482 char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string(); |
| 0 | 483 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
| 484 strlen(current) + strlen(loader2) + strlen(resolved) + | |
| 485 strlen(failed_type_name); | |
| 486 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
| 487 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, | |
| 488 resolved, failed_type_name); | |
| 489 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); | |
| 490 } | |
| 491 } | |
| 492 } | |
| 493 } | |
| 494 | |
| 495 void LinkResolver::resolve_interface_method(methodHandle& resolved_method, | |
| 496 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
497 Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
498 Symbol* method_signature, |
| 0 | 499 KlassHandle current_klass, |
| 500 bool check_access, TRAPS) { | |
| 501 | |
| 502 // check if klass is interface | |
| 503 if (!resolved_klass->is_interface()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
504 ResourceMark rm(THREAD); |
| 0 | 505 char buf[200]; |
| 506 jio_snprintf(buf, sizeof(buf), "Found class %s, but interface was expected", Klass::cast(resolved_klass())->external_name()); | |
| 507 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 508 } | |
| 509 | |
| 510 // lookup method in this interface or its super, java.lang.Object | |
| 511 lookup_instance_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK); | |
| 512 | |
| 513 if (resolved_method.is_null()) { | |
| 514 // lookup method in all the super-interfaces | |
| 515 lookup_method_in_interfaces(resolved_method, resolved_klass, method_name, method_signature, CHECK); | |
| 516 if (resolved_method.is_null()) { | |
| 517 // no method found | |
| 518 ResourceMark rm(THREAD); | |
| 519 THROW_MSG(vmSymbols::java_lang_NoSuchMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
520 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
521 method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
522 method_signature)); |
| 0 | 523 } |
| 524 } | |
| 525 | |
| 526 if (check_access) { | |
| 527 HandleMark hm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
528 Handle loader (THREAD, InstanceKlass::cast(current_klass())->class_loader()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
529 Handle class_loader (THREAD, InstanceKlass::cast(resolved_method->method_holder())->class_loader()); |
| 0 | 530 { |
| 531 ResourceMark rm(THREAD); | |
| 532 char* failed_type_name = | |
| 533 SystemDictionary::check_signature_loaders(method_signature, loader, | |
| 534 class_loader, true, CHECK); | |
| 535 if (failed_type_name != NULL) { | |
| 536 const char* msg = "loader constraint violation: when resolving " | |
| 537 "interface method \"%s\" the class loader (instance of %s) of the " | |
| 538 "current class, %s, and the class loader (instance of %s) for " | |
| 539 "resolved class, %s, have different Class objects for the type %s " | |
| 540 "used in the signature"; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
541 char* sig = Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()),method_name,method_signature); |
| 0 | 542 const char* loader1 = SystemDictionary::loader_name(loader()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
543 char* current = InstanceKlass::cast(current_klass())->name()->as_C_string(); |
| 0 | 544 const char* loader2 = SystemDictionary::loader_name(class_loader()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
545 char* resolved = InstanceKlass::cast(resolved_klass())->name()->as_C_string(); |
| 0 | 546 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
| 547 strlen(current) + strlen(loader2) + strlen(resolved) + | |
| 548 strlen(failed_type_name); | |
| 549 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
| 550 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, | |
| 551 resolved, failed_type_name); | |
| 552 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); | |
| 553 } | |
| 554 } | |
| 555 } | |
| 556 } | |
| 557 | |
| 558 //------------------------------------------------------------------------------------------------------------------------ | |
| 559 // Field resolution | |
| 560 | |
| 561 void LinkResolver::check_field_accessability(KlassHandle ref_klass, | |
| 562 KlassHandle resolved_klass, | |
| 563 KlassHandle sel_klass, | |
| 564 fieldDescriptor& fd, | |
| 565 TRAPS) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
566 if (!Reflection::verify_field_access(ref_klass(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
567 resolved_klass(), |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
568 sel_klass(), |
| 0 | 569 fd.access_flags(), |
| 570 true)) { | |
| 571 ResourceMark rm(THREAD); | |
| 572 Exceptions::fthrow( | |
| 573 THREAD_AND_LOCATION, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
574 vmSymbols::java_lang_IllegalAccessError(), |
| 0 | 575 "tried to access field %s.%s from class %s", |
| 576 sel_klass->external_name(), | |
| 577 fd.name()->as_C_string(), | |
| 578 ref_klass->external_name() | |
| 579 ); | |
| 580 return; | |
| 581 } | |
| 582 } | |
| 583 | |
| 584 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS) { | |
| 585 resolve_field(result, pool, index, byte, check_only, true, CHECK); | |
| 586 } | |
| 587 | |
| 588 void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS) { | |
| 589 assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic || | |
| 590 byte == Bytecodes::_getfield || byte == Bytecodes::_putfield, "bad bytecode"); | |
| 591 | |
| 592 bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic); | |
| 593 bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic); | |
| 594 | |
| 595 // resolve specified klass | |
| 596 KlassHandle resolved_klass; | |
| 597 if (update_pool) { | |
| 598 resolve_klass(resolved_klass, pool, index, CHECK); | |
| 599 } else { | |
| 600 resolve_klass_no_update(resolved_klass, pool, index, CHECK); | |
| 601 } | |
| 602 // Load these early in case the resolve of the containing klass fails | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
603 Symbol* field = pool->name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
604 Symbol* sig = pool->signature_ref_at(index); |
| 0 | 605 // Check if there's a resolved klass containing the field |
| 606 if( resolved_klass.is_null() ) { | |
| 607 ResourceMark rm(THREAD); | |
| 608 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); | |
| 609 } | |
| 610 | |
| 611 // Resolve instance field | |
| 612 fieldDescriptor fd; // find_field initializes fd if found | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
613 KlassHandle sel_klass(THREAD, InstanceKlass::cast(resolved_klass())->find_field(field, sig, &fd)); |
| 0 | 614 // check if field exists; i.e., if a klass containing the field def has been selected |
| 615 if (sel_klass.is_null()){ | |
| 616 ResourceMark rm(THREAD); | |
| 617 THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string()); | |
| 618 } | |
| 619 | |
| 620 // check access | |
| 621 KlassHandle ref_klass(THREAD, pool->pool_holder()); | |
| 622 check_field_accessability(ref_klass, resolved_klass, sel_klass, fd, CHECK); | |
| 623 | |
| 624 // check for errors | |
| 625 if (is_static != fd.is_static()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
626 ResourceMark rm(THREAD); |
| 0 | 627 char msg[200]; |
| 628 jio_snprintf(msg, sizeof(msg), "Expected %s field %s.%s", is_static ? "static" : "non-static", Klass::cast(resolved_klass())->external_name(), fd.name()->as_C_string()); | |
| 629 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), msg); | |
| 630 } | |
| 631 | |
| 632 // Final fields can only be accessed from its own class. | |
| 633 if (is_put && fd.access_flags().is_final() && sel_klass() != pool->pool_holder()) { | |
| 634 THROW(vmSymbols::java_lang_IllegalAccessError()); | |
| 635 } | |
| 636 | |
| 637 // initialize resolved_klass if necessary | |
| 638 // note 1: the klass which declared the field must be initialized (i.e, sel_klass) | |
| 639 // according to the newest JVM spec (5.5, p.170) - was bug (gri 7/28/99) | |
| 640 // | |
| 641 // note 2: we don't want to force initialization if we are just checking | |
| 642 // if the field access is legal; e.g., during compilation | |
| 643 if (is_static && !check_only) { | |
| 644 sel_klass->initialize(CHECK); | |
| 645 } | |
| 646 | |
| 647 { | |
| 648 HandleMark hm(THREAD); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
649 Handle ref_loader (THREAD, InstanceKlass::cast(ref_klass())->class_loader()); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
650 Handle sel_loader (THREAD, InstanceKlass::cast(sel_klass())->class_loader()); |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
651 Symbol* signature_ref = pool->signature_ref_at(index); |
| 0 | 652 { |
| 653 ResourceMark rm(THREAD); | |
| 654 char* failed_type_name = | |
| 655 SystemDictionary::check_signature_loaders(signature_ref, | |
| 656 ref_loader, sel_loader, | |
| 657 false, | |
| 658 CHECK); | |
| 659 if (failed_type_name != NULL) { | |
| 660 const char* msg = "loader constraint violation: when resolving field" | |
| 661 " \"%s\" the class loader (instance of %s) of the referring class, " | |
| 662 "%s, and the class loader (instance of %s) for the field's resolved " | |
| 663 "type, %s, have different Class objects for that type"; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
664 char* field_name = field->as_C_string(); |
| 0 | 665 const char* loader1 = SystemDictionary::loader_name(ref_loader()); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
666 char* sel = InstanceKlass::cast(sel_klass())->name()->as_C_string(); |
| 0 | 667 const char* loader2 = SystemDictionary::loader_name(sel_loader()); |
| 668 size_t buflen = strlen(msg) + strlen(field_name) + strlen(loader1) + | |
| 669 strlen(sel) + strlen(loader2) + strlen(failed_type_name); | |
| 670 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
| 671 jio_snprintf(buf, buflen, msg, field_name, loader1, sel, loader2, | |
| 672 failed_type_name); | |
| 673 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); | |
| 674 } | |
| 675 } | |
| 676 } | |
| 677 | |
| 678 // return information. note that the klass is set to the actual klass containing the | |
| 679 // field, otherwise access of static fields in superclasses will not work. | |
| 680 KlassHandle holder (THREAD, fd.field_holder()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
681 Symbol* name = fd.name(); |
| 0 | 682 result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags()); |
| 683 } | |
| 684 | |
| 685 | |
| 686 //------------------------------------------------------------------------------------------------------------------------ | |
| 687 // Invoke resolution | |
| 688 // | |
| 689 // Naming conventions: | |
| 690 // | |
| 691 // resolved_method the specified method (i.e., static receiver specified via constant pool index) | |
| 692 // sel_method the selected method (selected via run-time lookup; e.g., based on dynamic receiver class) | |
| 693 // resolved_klass the specified klass (i.e., specified via constant pool index) | |
| 694 // recv_klass the receiver klass | |
| 695 | |
| 696 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
697 void LinkResolver::resolve_static_call(CallInfo& result, KlassHandle& resolved_klass, Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
698 Symbol* method_signature, KlassHandle current_klass, |
| 0 | 699 bool check_access, bool initialize_class, TRAPS) { |
| 700 methodHandle resolved_method; | |
| 701 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 702 resolved_klass = KlassHandle(THREAD, Klass::cast(resolved_method->method_holder())); | |
| 703 | |
| 704 // Initialize klass (this should only happen if everything is ok) | |
| 705 if (initialize_class && resolved_klass->should_be_initialized()) { | |
| 706 resolved_klass->initialize(CHECK); | |
| 707 linktime_resolve_static_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 708 } | |
| 709 | |
| 710 // setup result | |
| 711 result.set_static(resolved_klass, resolved_method, CHECK); | |
| 712 } | |
| 713 | |
| 714 // throws linktime exceptions | |
| 715 void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
716 Symbol* method_name, Symbol* method_signature, |
| 0 | 717 KlassHandle current_klass, bool check_access, TRAPS) { |
| 718 | |
| 719 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 720 assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier"); | |
| 721 | |
| 722 // check if static | |
| 723 if (!resolved_method->is_static()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
724 ResourceMark rm(THREAD); |
| 0 | 725 char buf[200]; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
726 jio_snprintf(buf, sizeof(buf), "Expected static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 727 resolved_method->name(), |
| 728 resolved_method->signature())); | |
| 729 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 730 } | |
| 731 } | |
| 732 | |
| 733 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
734 void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
735 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { |
| 0 | 736 methodHandle resolved_method; |
| 737 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 738 runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK); | |
| 739 } | |
| 740 | |
| 741 // throws linktime exceptions | |
| 742 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
743 Symbol* method_name, Symbol* method_signature, |
| 0 | 744 KlassHandle current_klass, bool check_access, TRAPS) { |
| 745 | |
| 746 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 747 | |
| 748 // check if method name is <init>, that it is found in same klass as static type | |
| 749 if (resolved_method->name() == vmSymbols::object_initializer_name() && | |
| 750 resolved_method->method_holder() != resolved_klass()) { | |
| 751 ResourceMark rm(THREAD); | |
| 752 Exceptions::fthrow( | |
| 753 THREAD_AND_LOCATION, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
754 vmSymbols::java_lang_NoSuchMethodError(), |
| 0 | 755 "%s: method %s%s not found", |
| 756 resolved_klass->external_name(), | |
| 757 resolved_method->name()->as_C_string(), | |
| 758 resolved_method->signature()->as_C_string() | |
| 759 ); | |
| 760 return; | |
| 761 } | |
| 762 | |
| 763 // check if not static | |
| 764 if (resolved_method->is_static()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
765 ResourceMark rm(THREAD); |
| 0 | 766 char buf[200]; |
| 767 jio_snprintf(buf, sizeof(buf), | |
| 768 "Expecting non-static method %s", | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
769 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 770 resolved_method->name(), |
| 771 resolved_method->signature())); | |
| 772 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 773 } | |
| 774 } | |
| 775 | |
| 776 // throws runtime exceptions | |
| 777 void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, | |
| 778 KlassHandle current_klass, bool check_access, TRAPS) { | |
| 779 | |
| 780 // resolved method is selected method unless we have an old-style lookup | |
| 781 methodHandle sel_method(THREAD, resolved_method()); | |
| 782 | |
| 783 // check if this is an old-style super call and do a new lookup if so | |
| 784 { KlassHandle method_klass = KlassHandle(THREAD, | |
| 785 resolved_method->method_holder()); | |
| 786 | |
| 787 if (check_access && | |
| 788 // a) check if ACC_SUPER flag is set for the current class | |
| 789 current_klass->is_super() && | |
| 790 // b) check if the method class is a superclass of the current class (superclass relation is not reflexive!) | |
| 791 current_klass->is_subtype_of(method_klass()) && current_klass() != method_klass() && | |
| 792 // c) check if the method is not <init> | |
| 793 resolved_method->name() != vmSymbols::object_initializer_name()) { | |
| 794 // Lookup super method | |
| 795 KlassHandle super_klass(THREAD, current_klass->super()); | |
| 796 lookup_instance_method_in_klasses(sel_method, super_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
797 resolved_method->name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
798 resolved_method->signature(), CHECK); |
| 0 | 799 // check if found |
| 800 if (sel_method.is_null()) { | |
| 801 ResourceMark rm(THREAD); | |
| 802 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
803 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 804 resolved_method->name(), |
| 805 resolved_method->signature())); | |
| 806 } | |
| 807 } | |
| 808 } | |
| 809 | |
| 810 // check if not static | |
| 811 if (sel_method->is_static()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
812 ResourceMark rm(THREAD); |
| 0 | 813 char buf[200]; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
814 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 815 resolved_method->name(), |
| 816 resolved_method->signature())); | |
| 817 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 818 } | |
| 819 | |
| 820 // check if abstract | |
| 821 if (sel_method->is_abstract()) { | |
| 822 ResourceMark rm(THREAD); | |
| 823 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
824 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 825 sel_method->name(), |
| 826 sel_method->signature())); | |
| 827 } | |
| 828 | |
| 829 // setup result | |
| 830 result.set_static(resolved_klass, sel_method, CHECK); | |
| 831 } | |
| 832 | |
| 833 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHandle receiver_klass, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
834 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, |
| 0 | 835 bool check_access, bool check_null_and_abstract, TRAPS) { |
| 836 methodHandle resolved_method; | |
| 837 linktime_resolve_virtual_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 838 runtime_resolve_virtual_method(result, resolved_method, resolved_klass, recv, receiver_klass, check_null_and_abstract, CHECK); | |
| 839 } | |
| 840 | |
| 841 // throws linktime exceptions | |
| 842 void LinkResolver::linktime_resolve_virtual_method(methodHandle &resolved_method, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
843 Symbol* method_name, Symbol* method_signature, |
| 0 | 844 KlassHandle current_klass, bool check_access, TRAPS) { |
| 845 // normal method resolution | |
| 846 resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 847 | |
| 848 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); | |
| 849 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); | |
| 850 | |
| 851 // check if not static | |
| 852 if (resolved_method->is_static()) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
853 ResourceMark rm(THREAD); |
| 0 | 854 char buf[200]; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
855 jio_snprintf(buf, sizeof(buf), "Expecting non-static method %s", Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 856 resolved_method->name(), |
| 857 resolved_method->signature())); | |
| 858 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 859 } | |
| 860 } | |
| 861 | |
| 862 // throws runtime exceptions | |
| 863 void LinkResolver::runtime_resolve_virtual_method(CallInfo& result, | |
| 864 methodHandle resolved_method, | |
| 865 KlassHandle resolved_klass, | |
| 866 Handle recv, | |
| 867 KlassHandle recv_klass, | |
| 868 bool check_null_and_abstract, | |
| 869 TRAPS) { | |
| 870 | |
| 871 // setup default return values | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
872 int vtable_index = Method::invalid_vtable_index; |
| 0 | 873 methodHandle selected_method; |
| 874 | |
| 875 assert(recv.is_null() || recv->is_oop(), "receiver is not an oop"); | |
| 876 | |
| 877 // runtime method resolution | |
| 878 if (check_null_and_abstract && recv.is_null()) { // check if receiver exists | |
| 879 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 880 } | |
| 881 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
882 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s |
| 0 | 883 // has not been rewritten, and the vtable initialized. |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
884 assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); |
| 0 | 885 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
886 // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s |
| 0 | 887 // has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since |
| 888 // a missing receiver might result in a bogus lookup. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
889 assert(InstanceKlass::cast(resolved_method->method_holder())->is_linked(), "must be linked"); |
| 0 | 890 |
| 891 // do lookup based on receiver klass using the vtable index | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
892 if (resolved_method->method_holder()->is_interface()) { // miranda method |
| 0 | 893 vtable_index = vtable_index_of_miranda_method(resolved_klass, |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
894 resolved_method->name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
895 resolved_method->signature(), CHECK); |
| 0 | 896 assert(vtable_index >= 0 , "we should have valid vtable index at this point"); |
| 897 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
898 InstanceKlass* inst = InstanceKlass::cast(recv_klass()); |
| 0 | 899 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); |
| 900 } else { | |
| 901 // at this point we are sure that resolved_method is virtual and not | |
| 902 // a miranda method; therefore, it must have a valid vtable index. | |
| 903 vtable_index = resolved_method->vtable_index(); | |
| 904 // We could get a negative vtable_index for final methods, | |
| 905 // because as an optimization they are they are never put in the vtable, | |
| 906 // unless they override an existing method. | |
| 907 // If we do get a negative, it means the resolved method is the the selected | |
| 908 // method, and it can never be changed by an override. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
909 if (vtable_index == Method::nonvirtual_vtable_index) { |
| 0 | 910 assert(resolved_method->can_be_statically_bound(), "cannot override this method"); |
| 911 selected_method = resolved_method; | |
| 912 } else { | |
| 913 // recv_klass might be an arrayKlassOop but all vtables start at | |
| 914 // the same place. The cast is to avoid virtual call and assertion. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
915 InstanceKlass* inst = (InstanceKlass*)recv_klass(); |
| 0 | 916 selected_method = methodHandle(THREAD, inst->method_at_vtable(vtable_index)); |
| 917 } | |
| 918 } | |
| 919 | |
| 920 // check if method exists | |
| 921 if (selected_method.is_null()) { | |
| 922 ResourceMark rm(THREAD); | |
| 923 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
924 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 925 resolved_method->name(), |
| 926 resolved_method->signature())); | |
| 927 } | |
| 928 | |
| 929 // check if abstract | |
| 930 if (check_null_and_abstract && selected_method->is_abstract()) { | |
| 931 ResourceMark rm(THREAD); | |
| 932 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
933 Method::name_and_sig_as_C_string(Klass::cast(resolved_klass()), |
| 0 | 934 selected_method->name(), |
| 935 selected_method->signature())); | |
| 936 } | |
| 937 | |
| 938 // setup result | |
| 939 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK); | |
| 940 } | |
| 941 | |
| 942 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHandle recv_klass, KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
943 Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, |
| 0 | 944 bool check_access, bool check_null_and_abstract, TRAPS) { |
| 945 methodHandle resolved_method; | |
| 946 linktime_resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 947 runtime_resolve_interface_method(result, resolved_method, resolved_klass, recv, recv_klass, check_null_and_abstract, CHECK); | |
| 948 } | |
| 949 | |
| 950 // throws linktime exceptions | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
951 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
952 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) { |
| 0 | 953 // normal interface method resolution |
| 954 resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK); | |
| 955 | |
| 956 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier"); | |
| 957 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier"); | |
| 958 } | |
| 959 | |
| 960 // throws runtime exceptions | |
| 961 void LinkResolver::runtime_resolve_interface_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass, | |
| 962 Handle recv, KlassHandle recv_klass, bool check_null_and_abstract, TRAPS) { | |
| 963 // check if receiver exists | |
| 964 if (check_null_and_abstract && recv.is_null()) { | |
| 965 THROW(vmSymbols::java_lang_NullPointerException()); | |
| 966 } | |
| 967 | |
| 968 // check if receiver klass implements the resolved interface | |
| 969 if (!recv_klass->is_subtype_of(resolved_klass())) { | |
|
3324
acf5e660c71a
6728025: LinkResolver is missing some ResourceMarks
jcoomes
parents:
2460
diff
changeset
|
970 ResourceMark rm(THREAD); |
| 0 | 971 char buf[200]; |
| 972 jio_snprintf(buf, sizeof(buf), "Class %s does not implement the requested interface %s", | |
| 973 (Klass::cast(recv_klass()))->external_name(), | |
| 974 (Klass::cast(resolved_klass()))->external_name()); | |
| 975 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf); | |
| 976 } | |
| 977 // do lookup based on receiver klass | |
| 978 methodHandle sel_method; | |
| 979 lookup_instance_method_in_klasses(sel_method, recv_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
980 resolved_method->name(), |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
981 resolved_method->signature(), CHECK); |
| 0 | 982 // check if method exists |
| 983 if (sel_method.is_null()) { | |
| 984 ResourceMark rm(THREAD); | |
| 985 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
986 Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), |
| 0 | 987 resolved_method->name(), |
| 988 resolved_method->signature())); | |
| 989 } | |
| 990 // check if public | |
| 991 if (!sel_method->is_public()) { | |
| 992 ResourceMark rm(THREAD); | |
| 993 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
994 Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), |
| 0 | 995 sel_method->name(), |
| 996 sel_method->signature())); | |
| 997 } | |
| 998 // check if abstract | |
| 999 if (check_null_and_abstract && sel_method->is_abstract()) { | |
| 1000 ResourceMark rm(THREAD); | |
| 1001 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1002 Method::name_and_sig_as_C_string(Klass::cast(recv_klass()), |
| 0 | 1003 sel_method->name(), |
| 1004 sel_method->signature())); | |
| 1005 } | |
| 1006 // setup result | |
| 1007 result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, CHECK); | |
| 1008 } | |
| 1009 | |
| 1010 | |
| 1011 methodHandle LinkResolver::linktime_resolve_interface_method_or_null( | |
| 1012 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1013 Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1014 Symbol* method_signature, |
| 0 | 1015 KlassHandle current_klass, |
| 1016 bool check_access) { | |
| 1017 EXCEPTION_MARK; | |
| 1018 methodHandle method_result; | |
| 1019 linktime_resolve_interface_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); | |
| 1020 if (HAS_PENDING_EXCEPTION) { | |
| 1021 CLEAR_PENDING_EXCEPTION; | |
| 1022 return methodHandle(); | |
| 1023 } else { | |
| 1024 return method_result; | |
| 1025 } | |
| 1026 } | |
| 1027 | |
| 1028 methodHandle LinkResolver::linktime_resolve_virtual_method_or_null( | |
| 1029 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1030 Symbol* method_name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1031 Symbol* method_signature, |
| 0 | 1032 KlassHandle current_klass, |
| 1033 bool check_access) { | |
| 1034 EXCEPTION_MARK; | |
| 1035 methodHandle method_result; | |
| 1036 linktime_resolve_virtual_method(method_result, resolved_klass, method_name, method_signature, current_klass, check_access, THREAD); | |
| 1037 if (HAS_PENDING_EXCEPTION) { | |
| 1038 CLEAR_PENDING_EXCEPTION; | |
| 1039 return methodHandle(); | |
| 1040 } else { | |
| 1041 return method_result; | |
| 1042 } | |
| 1043 } | |
| 1044 | |
| 1045 methodHandle LinkResolver::resolve_virtual_call_or_null( | |
| 1046 KlassHandle receiver_klass, | |
| 1047 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1048 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1049 Symbol* signature, |
| 0 | 1050 KlassHandle current_klass) { |
| 1051 EXCEPTION_MARK; | |
| 1052 CallInfo info; | |
| 1053 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | |
| 1054 if (HAS_PENDING_EXCEPTION) { | |
| 1055 CLEAR_PENDING_EXCEPTION; | |
| 1056 return methodHandle(); | |
| 1057 } | |
| 1058 return info.selected_method(); | |
| 1059 } | |
| 1060 | |
| 1061 methodHandle LinkResolver::resolve_interface_call_or_null( | |
| 1062 KlassHandle receiver_klass, | |
| 1063 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1064 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1065 Symbol* signature, |
| 0 | 1066 KlassHandle current_klass) { |
| 1067 EXCEPTION_MARK; | |
| 1068 CallInfo info; | |
| 1069 resolve_interface_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | |
| 1070 if (HAS_PENDING_EXCEPTION) { | |
| 1071 CLEAR_PENDING_EXCEPTION; | |
| 1072 return methodHandle(); | |
| 1073 } | |
| 1074 return info.selected_method(); | |
| 1075 } | |
| 1076 | |
| 1077 int LinkResolver::resolve_virtual_vtable_index( | |
| 1078 KlassHandle receiver_klass, | |
| 1079 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1080 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1081 Symbol* signature, |
| 0 | 1082 KlassHandle current_klass) { |
| 1083 EXCEPTION_MARK; | |
| 1084 CallInfo info; | |
| 1085 resolve_virtual_call(info, Handle(), receiver_klass, resolved_klass, name, signature, current_klass, true, false, THREAD); | |
| 1086 if (HAS_PENDING_EXCEPTION) { | |
| 1087 CLEAR_PENDING_EXCEPTION; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1088 return Method::invalid_vtable_index; |
| 0 | 1089 } |
| 1090 return info.vtable_index(); | |
| 1091 } | |
| 1092 | |
| 1093 methodHandle LinkResolver::resolve_static_call_or_null( | |
| 1094 KlassHandle resolved_klass, | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1095 Symbol* name, |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1096 Symbol* signature, |
| 0 | 1097 KlassHandle current_klass) { |
| 1098 EXCEPTION_MARK; | |
| 1099 CallInfo info; | |
| 1100 resolve_static_call(info, resolved_klass, name, signature, current_klass, true, false, THREAD); | |
| 1101 if (HAS_PENDING_EXCEPTION) { | |
| 1102 CLEAR_PENDING_EXCEPTION; | |
| 1103 return methodHandle(); | |
| 1104 } | |
| 1105 return info.selected_method(); | |
| 1106 } | |
| 1107 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1108 methodHandle LinkResolver::resolve_special_call_or_null(KlassHandle resolved_klass, Symbol* name, Symbol* signature, |
| 0 | 1109 KlassHandle current_klass) { |
| 1110 EXCEPTION_MARK; | |
| 1111 CallInfo info; | |
| 1112 resolve_special_call(info, resolved_klass, name, signature, current_klass, true, THREAD); | |
| 1113 if (HAS_PENDING_EXCEPTION) { | |
| 1114 CLEAR_PENDING_EXCEPTION; | |
| 1115 return methodHandle(); | |
| 1116 } | |
| 1117 return info.selected_method(); | |
| 1118 } | |
| 1119 | |
| 1120 | |
| 1121 | |
| 1122 //------------------------------------------------------------------------------------------------------------------------ | |
| 1123 // ConstantPool entries | |
| 1124 | |
| 1125 void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) { | |
| 1126 switch (byte) { | |
| 1127 case Bytecodes::_invokestatic : resolve_invokestatic (result, pool, index, CHECK); break; | |
| 1128 case Bytecodes::_invokespecial : resolve_invokespecial (result, pool, index, CHECK); break; | |
| 1129 case Bytecodes::_invokevirtual : resolve_invokevirtual (result, recv, pool, index, CHECK); break; | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1130 case Bytecodes::_invokehandle : resolve_invokehandle (result, pool, index, CHECK); break; |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1131 case Bytecodes::_invokedynamic : resolve_invokedynamic (result, pool, index, CHECK); break; |
| 0 | 1132 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break; |
| 1133 } | |
| 1134 return; | |
| 1135 } | |
| 1136 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1137 void LinkResolver::resolve_pool(KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, |
| 0 | 1138 KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS) { |
| 1139 // resolve klass | |
| 1140 resolve_klass(resolved_klass, pool, index, CHECK); | |
| 1141 | |
| 1142 // Get name, signature, and static klass | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1143 method_name = pool->name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1144 method_signature = pool->signature_ref_at(index); |
| 0 | 1145 current_klass = KlassHandle(THREAD, pool->pool_holder()); |
| 1146 } | |
| 1147 | |
| 1148 | |
| 1149 void LinkResolver::resolve_invokestatic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { | |
| 1150 KlassHandle resolved_klass; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1151 Symbol* method_name = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1152 Symbol* method_signature = NULL; |
| 0 | 1153 KlassHandle current_klass; |
| 1154 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | |
| 1155 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); | |
| 1156 } | |
| 1157 | |
| 1158 | |
| 1159 void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { | |
| 1160 KlassHandle resolved_klass; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1161 Symbol* method_name = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1162 Symbol* method_signature = NULL; |
| 0 | 1163 KlassHandle current_klass; |
| 1164 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | |
| 1165 resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK); | |
| 1166 } | |
| 1167 | |
| 1168 | |
| 1169 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv, | |
| 1170 constantPoolHandle pool, int index, | |
| 1171 TRAPS) { | |
| 1172 | |
| 1173 KlassHandle resolved_klass; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1174 Symbol* method_name = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1175 Symbol* method_signature = NULL; |
| 0 | 1176 KlassHandle current_klass; |
| 1177 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1178 KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass()); |
| 0 | 1179 resolve_virtual_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); |
| 1180 } | |
| 1181 | |
| 1182 | |
| 1183 void LinkResolver::resolve_invokeinterface(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) { | |
| 1184 KlassHandle resolved_klass; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1185 Symbol* method_name = NULL; |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1186 Symbol* method_signature = NULL; |
| 0 | 1187 KlassHandle current_klass; |
| 1188 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1189 KlassHandle recvrKlass (THREAD, recv.is_null() ? (Klass*)NULL : recv->klass()); |
| 0 | 1190 resolve_interface_call(result, recv, recvrKlass, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK); |
| 1191 } | |
| 1192 | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1193 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1194 void LinkResolver::resolve_invokehandle(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1195 assert(EnableInvokeDynamic, ""); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1196 // This guy is reached from InterpreterRuntime::resolve_invokehandle. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1197 KlassHandle resolved_klass; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1198 Symbol* method_name = NULL; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1199 Symbol* method_signature = NULL; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1200 KlassHandle current_klass; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1201 resolve_pool(resolved_klass, method_name, method_signature, current_klass, pool, index, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1202 if (TraceMethodHandles) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1203 tty->print_cr("resolve_invokehandle %s %s", method_name->as_C_string(), method_signature->as_C_string()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1204 resolve_handle_call(result, resolved_klass, method_name, method_signature, current_klass, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1205 } |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1206 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1207 void LinkResolver::resolve_handle_call(CallInfo& result, KlassHandle resolved_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1208 Symbol* method_name, Symbol* method_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1209 KlassHandle current_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1210 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1211 // JSR 292: this must be an implicitly generated method MethodHandle.invokeExact(*...) or similar |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1212 assert(resolved_klass() == SystemDictionary::MethodHandle_klass(), ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1213 assert(MethodHandles::is_signature_polymorphic_name(method_name), ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1214 methodHandle resolved_method; |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1215 Handle resolved_appendix; |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1216 Handle resolved_method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1217 lookup_polymorphic_method(resolved_method, resolved_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1218 method_name, method_signature, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1219 current_klass, &resolved_appendix, &resolved_method_type, CHECK); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1220 result.set_handle(resolved_method, resolved_appendix, resolved_method_type, CHECK); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1221 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1222 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1223 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1224 void LinkResolver::resolve_invokedynamic(CallInfo& result, constantPoolHandle pool, int index, TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1225 assert(EnableInvokeDynamic, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1226 pool->set_invokedynamic(); // mark header to flag active call sites |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1227 |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1228 //resolve_pool(<resolved_klass>, method_name, method_signature, current_klass, pool, index, CHECK); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1229 Symbol* method_name = pool->name_ref_at(index); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1230 Symbol* method_signature = pool->signature_ref_at(index); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1231 KlassHandle current_klass = KlassHandle(THREAD, pool->pool_holder()); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1232 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1233 // Resolve the bootstrap specifier (BSM + optional arguments). |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1234 Handle bootstrap_specifier; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1235 // Check if CallSite has been bound already: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1236 ConstantPoolCacheEntry* cpce = pool->invokedynamic_cp_cache_entry_at(index); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1237 if (cpce->is_f1_null()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1238 int pool_index = cpce->constant_pool_index(); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1239 oop bsm_info = pool->resolve_bootstrap_specifier_at(pool_index, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1240 assert(bsm_info != NULL, ""); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1241 // FIXME: Cache this once per BootstrapMethods entry, not once per CONSTANT_InvokeDynamic. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1242 bootstrap_specifier = Handle(THREAD, bsm_info); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1243 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1244 if (!cpce->is_f1_null()) { |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1245 methodHandle method( THREAD, cpce->f1_as_method()); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1246 Handle appendix( THREAD, cpce->appendix_if_resolved(pool)); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1247 Handle method_type(THREAD, cpce->method_type_if_resolved(pool)); |
|
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1248 result.set_handle(method, appendix, method_type, CHECK); |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1249 return; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1250 } |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1251 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1252 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1253 tty->print_cr("resolve_invokedynamic #%d %s %s", |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6271
diff
changeset
|
1254 ConstantPool::decode_invokedynamic_index(index), |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1255 method_name->as_C_string(), method_signature->as_C_string()); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1256 tty->print(" BSM info: "); bootstrap_specifier->print(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1257 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1258 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1259 resolve_dynamic_call(result, bootstrap_specifier, method_name, method_signature, current_klass, CHECK); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1260 } |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1261 |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1262 void LinkResolver::resolve_dynamic_call(CallInfo& result, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1263 Handle bootstrap_specifier, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1264 Symbol* method_name, Symbol* method_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1265 KlassHandle current_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1266 TRAPS) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1267 // JSR 292: this must resolve to an implicitly generated method MH.linkToCallSite(*...) |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1268 // The appendix argument is likely to be a freshly-created CallSite. |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1269 Handle resolved_appendix; |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1270 Handle resolved_method_type; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1271 methodHandle resolved_method = |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1272 SystemDictionary::find_dynamic_call_site_invoker(current_klass, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1273 bootstrap_specifier, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1274 method_name, method_signature, |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1275 &resolved_appendix, |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1276 &resolved_method_type, |
|
6729
d17383603741
7196120: NPG: JSR 2292 test fails because missing fix for 7188911
twisti
parents:
6725
diff
changeset
|
1277 THREAD); |
|
3744
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1278 if (HAS_PENDING_EXCEPTION) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1279 if (TraceMethodHandles) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1280 tty->print_cr("invokedynamic throws BSME for "INTPTR_FORMAT, PENDING_EXCEPTION); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1281 PENDING_EXCEPTION->print(); |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1282 } |
|
3744
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1283 if (PENDING_EXCEPTION->is_a(SystemDictionary::BootstrapMethodError_klass())) { |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1284 // throw these guys, since they are already wrapped |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1285 return; |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1286 } |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1287 if (!PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) { |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1288 // intercept only LinkageErrors which might have failed to wrap |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1289 return; |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1290 } |
|
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1291 // See the "Linking Exceptions" section for the invokedynamic instruction in the JVMS. |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
3960
diff
changeset
|
1292 Handle nested_exception(THREAD, PENDING_EXCEPTION); |
|
3744
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1293 CLEAR_PENDING_EXCEPTION; |
|
6729
d17383603741
7196120: NPG: JSR 2292 test fails because missing fix for 7188911
twisti
parents:
6725
diff
changeset
|
1294 THROW_CAUSE(vmSymbols::java_lang_BootstrapMethodError(), nested_exception) |
|
3744
60b8287df30e
7049415: Failure of resolution of sym.reference to the c.s.s. should be wrapped in BootstrapMethodError
jrose
parents:
3324
diff
changeset
|
1295 } |
|
6822
f6b0eb4e44cf
7200949: JSR 292: rubybench/bench/time/bench_base64.rb fails with jruby.jar not on boot class path
twisti
parents:
6729
diff
changeset
|
1296 result.set_handle(resolved_method, resolved_appendix, resolved_method_type, CHECK); |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1297 } |
|
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
1298 |
| 0 | 1299 //------------------------------------------------------------------------------------------------------------------------ |
| 1300 #ifndef PRODUCT | |
| 1301 | |
| 1302 void FieldAccessInfo::print() { | |
| 1303 ResourceMark rm; | |
| 1304 tty->print_cr("Field %s@%d", name()->as_C_string(), field_offset()); | |
| 1305 } | |
| 1306 | |
| 1307 #endif |