infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-04-01 18:50:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Coleen Phillimore 2016-05-27 16:39:49 +00:00
commit f0f9e93eb1
18 changed files with 543 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
hotspot/src/share/vm/ci/ciEnv.cpp
View File

@ -704,13 +704,14 @@ Method* ciEnv::lookup_method(InstanceKlass* accessor,
InstanceKlass* holder,
Symbol* name,
Symbol* sig,
Bytecodes::Code bc) {
Bytecodes::Code bc,
constantTag tag) {
EXCEPTION_CONTEXT;
KlassHandle h_accessor(THREAD, accessor);
KlassHandle h_holder(THREAD, holder);
LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
methodHandle dest_method;
LinkInfo link_info(h_holder, name, sig, h_accessor, /*check_access*/true);
LinkInfo link_info(h_holder, name, sig, h_accessor, LinkInfo::needs_access_check, tag);
switch (bc) {
case Bytecodes::_invokestatic:
dest_method =
@ -796,7 +797,9 @@ ciMethod* ciEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
if (holder_is_accessible) { // Our declared holder is loaded.
InstanceKlass* lookup = declared_holder->get_instanceKlass();
Method* m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc);
constantTag tag = cpool->tag_ref_at(index);
assert(accessor->get_instanceKlass() == cpool->pool_holder(), "not the pool holder?");
Method* m = lookup_method(accessor->get_instanceKlass(), lookup, name_sym, sig_sym, bc, tag);
if (m != NULL &&
(bc == Bytecodes::_invokestatic
? m->method_holder()->is_not_initialized()

5
hotspot/src/share/vm/ci/ciEnv.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -156,7 +156,8 @@ private:
InstanceKlass* holder,
Symbol* name,
Symbol* sig,
Bytecodes::Code bc);
Bytecodes::Code bc,
constantTag tag);
// Get a ciObject from the object factory. Ensures uniqueness
// of ciObjects.

3
hotspot/src/share/vm/ci/ciMethod.cpp
View File

@ -789,7 +789,8 @@ ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, boo
Symbol* h_name = name()->get_symbol();
Symbol* h_signature = signature()->get_symbol();
LinkInfo link_info(h_resolved, h_name, h_signature, caller_klass, check_access);
LinkInfo link_info(h_resolved, h_name, h_signature, caller_klass,
check_access ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
methodHandle m;
// Only do exact lookup if receiver klass has been linked. Otherwise,
// the vtable has not been setup, and the LinkResolver will fail.

50
hotspot/src/share/vm/interpreter/linkResolver.cpp
View File

@ -231,6 +231,7 @@ LinkInfo::LinkInfo(const constantPoolHandle& pool, int index, TRAPS) {
// Get name, signature, and static klass
_name = pool->name_ref_at(index);
_signature = pool->signature_ref_at(index);
_tag = pool->tag_ref_at(index);
_current_klass = KlassHandle(THREAD, pool->pool_holder());
// Coming from the constant pool always checks access
@ -573,7 +574,7 @@ methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
Symbol* method_signature = pool->signature_ref_at(index);
KlassHandle current_klass(THREAD, pool->pool_holder());
LinkInfo link_info(resolved_klass, method_name, method_signature, current_klass);
return resolve_method(link_info, /*require_methodref*/false, THREAD);
return resolve_method(link_info, code, THREAD);
}
LinkInfo link_info(pool, index, CHECK_NULL);
@ -591,9 +592,9 @@ methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
if (code == Bytecodes::_invokeinterface) {
return resolve_interface_method(link_info, code, THREAD);
} else if (code == Bytecodes::_invokevirtual) {
return resolve_method(link_info, /*require_methodref*/true, THREAD);
return resolve_method(link_info, code, THREAD);
} else if (!resolved_klass->is_interface()) {
return resolve_method(link_info, /*require_methodref*/false, THREAD);
return resolve_method(link_info, code, THREAD);
} else {
return resolve_interface_method(link_info, code, THREAD);
}
@ -663,13 +664,13 @@ void LinkResolver::check_field_loader_constraints(Symbol* field, Symbol* sig,
}
methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
bool require_methodref, TRAPS) {
Bytecodes::Code code, TRAPS) {
Handle nested_exception;
KlassHandle resolved_klass = link_info.resolved_klass();
// 1. check if methodref required, that resolved_klass is not interfacemethodref
if (require_methodref && resolved_klass->is_interface()) {
// 1. For invokevirtual, cannot call an interface method
if (code == Bytecodes::_invokevirtual && resolved_klass->is_interface()) {
ResourceMark rm(THREAD);
char buf[200];
jio_snprintf(buf, sizeof(buf), "Found interface %s, but class was expected",
@ -677,11 +678,20 @@ methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
// 2. lookup method in resolved klass and its super klasses
// 2. check constant pool tag for called method - must be JVM_CONSTANT_Methodref
if (!link_info.tag().is_invalid() && !link_info.tag().is_method()) {
ResourceMark rm(THREAD);
char buf[200];
jio_snprintf(buf, sizeof(buf), "Method %s must be Methodref constant", link_info.method_string());
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
// 3. lookup method in resolved klass and its super klasses
methodHandle resolved_method = lookup_method_in_klasses(link_info, true, false, CHECK_NULL);
// 4. lookup method in all the interfaces implemented by the resolved klass
if (resolved_method.is_null() && !resolved_klass->is_array_klass()) { // not found in the class hierarchy
// 3. lookup method in all the interfaces implemented by the resolved klass
resolved_method = lookup_method_in_interfaces(link_info, CHECK_NULL);
if (resolved_method.is_null()) {
@ -694,8 +704,8 @@ methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
}
}
// 5. method lookup failed
if (resolved_method.is_null()) {
// 4. method lookup failed
ResourceMark rm(THREAD);
THROW_MSG_CAUSE_(vmSymbols::java_lang_NoSuchMethodError(),
Method::name_and_sig_as_C_string(resolved_klass(),
@ -704,7 +714,7 @@ methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
nested_exception, NULL);
}
// 5. access checks, access checking may be turned off when calling from within the VM.
// 6. access checks, access checking may be turned off when calling from within the VM.
KlassHandle current_klass = link_info.current_klass();
if (link_info.check_access()) {
assert(current_klass.not_null() , "current_klass should not be null");
@ -766,6 +776,14 @@ methodHandle LinkResolver::resolve_interface_method(const LinkInfo& link_info, B
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
// check constant pool tag for called method - must be JVM_CONSTANT_InterfaceMethodref
if (!link_info.tag().is_invalid() && !link_info.tag().is_interface_method()) {
ResourceMark rm(THREAD);
char buf[200];
jio_snprintf(buf, sizeof(buf), "Method %s must be InterfaceMethodref constant", link_info.method_string());
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
// lookup method in this interface or its super, java.lang.Object
// JDK8: also look for static methods
methodHandle resolved_method = lookup_method_in_klasses(link_info, false, true, CHECK_NULL);
@ -956,7 +974,8 @@ void LinkResolver::resolve_static_call(CallInfo& result,
resolved_klass->initialize(CHECK);
// Use updated LinkInfo (to reresolve with resolved_klass as method_holder?)
LinkInfo new_info(resolved_klass, link_info.name(), link_info.signature(),
link_info.current_klass(), link_info.check_access());
link_info.current_klass(),
link_info.check_access() ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
resolved_method = linktime_resolve_static_method(new_info, CHECK);
}
@ -971,7 +990,7 @@ methodHandle LinkResolver::linktime_resolve_static_method(const LinkInfo& link_i
KlassHandle resolved_klass = link_info.resolved_klass();
methodHandle resolved_method;
if (!resolved_klass->is_interface()) {
resolved_method = resolve_method(link_info, /*require_methodref*/false, CHECK_NULL);
resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
} else {
resolved_method = resolve_interface_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
}
@ -1014,7 +1033,7 @@ methodHandle LinkResolver::linktime_resolve_special_method(const LinkInfo& link_
methodHandle resolved_method;
if (!resolved_klass->is_interface()) {
resolved_method = resolve_method(link_info, /*require_methodref*/false, CHECK_NULL);
resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
} else {
resolved_method = resolve_interface_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
}
@ -1164,7 +1183,7 @@ void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, KlassHand
methodHandle LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
TRAPS) {
// normal method resolution
methodHandle resolved_method = resolve_method(link_info, /*require_methodref*/true, CHECK_NULL);
methodHandle resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
@ -1173,6 +1192,7 @@ methodHandle LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_
KlassHandle resolved_klass = link_info.resolved_klass();
KlassHandle current_klass = link_info.current_klass();
// This is impossible, if resolve_klass is an interface, we've thrown icce in resolve_method
if (resolved_klass->is_interface() && resolved_method->is_private()) {
ResourceMark rm(THREAD);
char buf[200];
@ -1482,7 +1502,7 @@ void LinkResolver::resolve_invoke(CallInfo& result, Handle& recv,
KlassHandle defc = attached_method->method_holder();
Symbol* name = attached_method->name();
Symbol* type = attached_method->signature();
LinkInfo link_info(defc, name, type, KlassHandle(), /*check_access=*/false);
LinkInfo link_info(defc, name, type);
switch(byte) {
case Bytecodes::_invokevirtual:
resolve_virtual_call(result, recv, recv->klass(), link_info,

25
hotspot/src/share/vm/interpreter/linkResolver.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -137,20 +137,35 @@ class LinkInfo : public StackObj {
KlassHandle _resolved_klass; // class that the constant pool entry points to
KlassHandle _current_klass; // class that owns the constant pool
bool _check_access;
constantTag _tag;
public:
enum AccessCheck {
needs_access_check,
skip_access_check
};
LinkInfo(const constantPoolHandle& pool, int index, TRAPS);
// Condensed information from other call sites within the vm.
LinkInfo(KlassHandle resolved_klass, Symbol* name, Symbol* signature,
KlassHandle current_klass, bool check_access = true) :
LinkInfo(KlassHandle resolved_klass, Symbol* name, Symbol* signature, KlassHandle current_klass,
AccessCheck check_access = needs_access_check,
constantTag tag = JVM_CONSTANT_Invalid) :
_resolved_klass(resolved_klass),
_name(name), _signature(signature), _current_klass(current_klass),
_check_access(check_access) {}
_check_access(check_access == needs_access_check), _tag(tag) {}
// Case where we just find the method and don't check access against the current class
LinkInfo(KlassHandle resolved_klass, Symbol*name, Symbol* signature) :
_resolved_klass(resolved_klass),
_name(name), _signature(signature), _current_klass(NULL),
_check_access(false), _tag(JVM_CONSTANT_Invalid) {}
// accessors
Symbol* name() const { return _name; }
Symbol* signature() const { return _signature; }
KlassHandle resolved_klass() const { return _resolved_klass; }
KlassHandle current_klass() const { return _current_klass; }
constantTag tag() const { return _tag; }
bool check_access() const { return _check_access; }
char* method_string() const;
@ -192,7 +207,7 @@ class LinkResolver: AllStatic {
KlassHandle sel_klass, TRAPS);
static methodHandle resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
static methodHandle resolve_method (const LinkInfo& link_info, bool require_methodref, TRAPS);
static methodHandle resolve_method (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
static methodHandle linktime_resolve_static_method (const LinkInfo& link_info, TRAPS);
static methodHandle linktime_resolve_special_method (const LinkInfo& link_info, TRAPS);

3
hotspot/src/share/vm/jvmci/jvmciCompilerToVM.cpp
View File

@ -661,8 +661,7 @@ C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_t
Symbol* h_name = method->name();
Symbol* h_signature = method->signature();
bool check_access = true;
LinkInfo link_info(h_resolved, h_name, h_signature, caller_klass, check_access);
LinkInfo link_info(h_resolved, h_name, h_signature, caller_klass);
methodHandle m;
// Only do exact lookup if receiver klass has been linked. Otherwise,
// the vtable has not been setup, and the LinkResolver will fail.

8
hotspot/src/share/vm/jvmci/jvmciEnv.cpp
View File

@ -286,11 +286,12 @@ methodHandle JVMCIEnv::lookup_method(instanceKlassHandle h_accessor,
instanceKlassHandle h_holder,
Symbol* name,
Symbol* sig,
Bytecodes::Code bc) {
Bytecodes::Code bc,
constantTag tag) {
JVMCI_EXCEPTION_CONTEXT;
LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));
methodHandle dest_method;
LinkInfo link_info(h_holder, name, sig, h_accessor, /*check_access*/true);
LinkInfo link_info(h_holder, name, sig, h_accessor, LinkInfo::needs_access_check, tag);
switch (bc) {
case Bytecodes::_invokestatic:
dest_method =
@ -363,7 +364,8 @@ methodHandle JVMCIEnv::get_method_by_index_impl(const constantPoolHandle& cpool,
if (holder_is_accessible) { // Our declared holder is loaded.
instanceKlassHandle lookup = get_instance_klass_for_declared_method_holder(holder);
methodHandle m = lookup_method(accessor, lookup, name_sym, sig_sym, bc);
constantTag tag = cpool->tag_ref_at(index);
methodHandle m = lookup_method(accessor, lookup, name_sym, sig_sym, bc, tag);
if (!m.is_null() &&
(bc == Bytecodes::_invokestatic
? InstanceKlass::cast(m->method_holder())->is_not_initialized()

5
hotspot/src/share/vm/jvmci/jvmciEnv.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -130,7 +130,8 @@ private:
instanceKlassHandle holder,
Symbol* name,
Symbol* sig,
Bytecodes::Code bc);
Bytecodes::Code bc,
constantTag tag);
private:

23
hotspot/src/share/vm/oops/constantPool.cpp
View File

@ -417,6 +417,19 @@ int ConstantPool::impl_name_and_type_ref_index_at(int which, bool uncached) {
return extract_high_short_from_int(ref_index);
}
constantTag ConstantPool::impl_tag_ref_at(int which, bool uncached) {
int pool_index = which;
if (!uncached && cache() != NULL) {
if (ConstantPool::is_invokedynamic_index(which)) {
// Invokedynamic index is index into resolved_references
pool_index = invokedynamic_cp_cache_entry_at(which)->constant_pool_index();
} else {
// change byte-ordering and go via cache
pool_index = remap_instruction_operand_from_cache(which);
}
}
return tag_at(pool_index);
}
int ConstantPool::impl_klass_ref_index_at(int which, bool uncached) {
guarantee(!ConstantPool::is_invokedynamic_index(which),
@ -672,6 +685,7 @@ oop ConstantPool::resolve_constant_at_impl(const constantPoolHandle& this_cp, in
int callee_index = this_cp->method_handle_klass_index_at(index);
Symbol* name = this_cp->method_handle_name_ref_at(index);
Symbol* signature = this_cp->method_handle_signature_ref_at(index);
constantTag m_tag = this_cp->tag_at(this_cp->method_handle_index_at(index));
{ ResourceMark rm(THREAD);
log_debug(class, resolve)("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s",
ref_kind, index, this_cp->method_handle_index_at(index),
@ -681,6 +695,15 @@ oop ConstantPool::resolve_constant_at_impl(const constantPoolHandle& this_cp, in
{ Klass* k = klass_at_impl(this_cp, callee_index, true, CHECK_NULL);
callee = KlassHandle(THREAD, k);
}
if ((callee->is_interface() && m_tag.is_method()) ||
(!callee->is_interface() && m_tag.is_interface_method())) {
ResourceMark rm(THREAD);
char buf[200];
jio_snprintf(buf, sizeof(buf), "Inconsistent constant data for %s.%s%s at index %d",
callee->name()->as_C_string(), name->as_C_string(), signature->as_C_string(), index);
THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
KlassHandle klass(THREAD, this_cp->pool_holder());
Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind,
callee, name, signature,

3
hotspot/src/share/vm/oops/constantPool.hpp
View File

@ -643,6 +643,8 @@ class ConstantPool : public Metadata {
int remap_instruction_operand_from_cache(int operand); // operand must be biased by CPCACHE_INDEX_TAG
constantTag tag_ref_at(int cp_cache_index) { return impl_tag_ref_at(cp_cache_index, false); }
// Lookup for entries consisting of (name_index, signature_index)
int name_ref_index_at(int which_nt); // == low-order jshort of name_and_type_at(which_nt)
int signature_ref_index_at(int which_nt); // == high-order jshort of name_and_type_at(which_nt)
@ -763,6 +765,7 @@ class ConstantPool : public Metadata {
Symbol* impl_signature_ref_at(int which, bool uncached);
int impl_klass_ref_index_at(int which, bool uncached);
int impl_name_and_type_ref_index_at(int which, bool uncached);
constantTag impl_tag_ref_at(int which, bool uncached);
// Used while constructing constant pool (only by ClassFileParser)
jint klass_index_at(int which) {

10
hotspot/src/share/vm/prims/methodHandles.cpp
View File

@ -713,12 +713,16 @@ Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS
TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty));
if (type == NULL) return empty; // no such signature exists in the VM
LinkInfo::AccessCheck access_check = caller.not_null() ?
LinkInfo::needs_access_check :
LinkInfo::skip_access_check;
// Time to do the lookup.
switch (flags & ALL_KINDS) {
case IS_METHOD:
{
CallInfo result;
LinkInfo link_info(defc, name, type, caller, caller.not_null());
LinkInfo link_info(defc, name, type, caller, access_check);
{
assert(!HAS_PENDING_EXCEPTION, "");
if (ref_kind == JVM_REF_invokeStatic) {
@ -755,7 +759,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS
case IS_CONSTRUCTOR:
{
CallInfo result;
LinkInfo link_info(defc, name, type, caller, caller.not_null());
LinkInfo link_info(defc, name, type, caller, access_check);
{
assert(!HAS_PENDING_EXCEPTION, "");
if (name == vmSymbols::object_initializer_name()) {
@ -776,7 +780,7 @@ Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS
fieldDescriptor result; // find_field initializes fd if found
{
assert(!HAS_PENDING_EXCEPTION, "");
LinkInfo link_info(defc, name, type, caller, /*check_access*/false);
LinkInfo link_info(defc, name, type, caller, LinkInfo::skip_access_check);
LinkResolver::resolve_field(result, link_info, Bytecodes::_nop, false, THREAD);
if (HAS_PENDING_EXCEPTION) {
return empty;

6
hotspot/src/share/vm/runtime/javaCalls.cpp
View File

@ -183,7 +183,7 @@ void JavaCalls::call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol*
CallInfo callinfo;
Handle receiver = args->receiver();
KlassHandle recvrKlass(THREAD, receiver.is_null() ? (Klass*)NULL : receiver->klass());
LinkInfo link_info(spec_klass, name, signature, KlassHandle(), /*check_access*/false);
LinkInfo link_info(spec_klass, name, signature);
LinkResolver::resolve_virtual_call(
callinfo, receiver, recvrKlass, link_info, true, CHECK);
methodHandle method = callinfo.selected_method();
@ -220,7 +220,7 @@ void JavaCalls::call_virtual(JavaValue* result, Handle receiver, KlassHandle spe
void JavaCalls::call_special(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
CallInfo callinfo;
LinkInfo link_info(klass, name, signature, KlassHandle(), /*check_access*/false);
LinkInfo link_info(klass, name, signature);
LinkResolver::resolve_special_call(callinfo, link_info, CHECK);
methodHandle method = callinfo.selected_method();
assert(method.not_null(), "should have thrown exception");
@ -255,7 +255,7 @@ void JavaCalls::call_special(JavaValue* result, Handle receiver, KlassHandle kla
void JavaCalls::call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
CallInfo callinfo;
LinkInfo link_info(klass, name, signature, KlassHandle(), /*check_access*/false);
LinkInfo link_info(klass, name, signature);
LinkResolver::resolve_static_call(callinfo, link_info, true, CHECK);
methodHandle method = callinfo.selected_method();
assert(method.not_null(), "should have thrown exception");

2
hotspot/src/share/vm/runtime/reflection.cpp
View File

@ -998,7 +998,7 @@ static methodHandle resolve_interface_call(instanceKlassHandle klass,
Symbol* signature = method->signature();
Symbol* name = method->name();
LinkResolver::resolve_interface_call(info, receiver, recv_klass,
LinkInfo(klass, name, signature, KlassHandle(), false),
LinkInfo(klass, name, signature),
true,
CHECK_(methodHandle()));
return info.selected_method();

254
hotspot/test/runtime/ConstantPool/BadMethodHandles.java Normal file
View File

@ -0,0 +1,254 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8087223
* @summary Adding constantTag to keep method call consistent with it.
* @library /testlibrary
* @modules java.base/jdk.internal.org.objectweb.asm
* java.base/jdk.internal.misc
* java.management
* @compile -XDignore.symbol.file BadMethodHandles.java
* @run main/othervm BadMethodHandles
*/
import jdk.internal.org.objectweb.asm.*;
import java.io.FileOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import static jdk.internal.org.objectweb.asm.Opcodes.*;
public class BadMethodHandles {
static byte[] dumpBadInterfaceMethodref() {
ClassWriter cw = new ClassWriter(0);
cw.visit(52, ACC_PUBLIC | ACC_SUPER, "BadInterfaceMethodref", null, "java/lang/Object", null);
Handle handle1 =
new Handle(Opcodes.H_INVOKEINTERFACE, "BadInterfaceMethodref", "m", "()V");
Handle handle2 =
new Handle(Opcodes.H_INVOKEINTERFACE, "BadInterfaceMethodref", "staticM", "()V");
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "m", "()V", null, null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("hello from m");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false/*intf*/);
mv.visitInsn(RETURN);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "staticM", "()V", null, null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("hello from staticM");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false/*intf*/);
mv.visitInsn(RETURN);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "runm", "()V", null, null);
mv.visitCode();
// REF_invokeStatic
mv.visitLdcInsn(handle1);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandle", "invoke", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "runStaticM", "()V", null, null);
mv.visitCode();
// REF_invokeStatic
mv.visitLdcInsn(handle2);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandle", "invoke", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
static byte[] dumpIBad() {
ClassWriter cw = new ClassWriter(0);
cw.visit(52, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "IBad", null, "java/lang/Object", null);
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "m", "()V", null, null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("hello from m");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false/*intf*/);
mv.visitInsn(RETURN);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "staticM", "()V", null, null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
mv.visitLdcInsn("hello from staticM");
mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false/*intf*/);
mv.visitInsn(RETURN);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
static byte[] dumpBadMethodref() {
ClassWriter cw = new ClassWriter(0);
cw.visit(52, ACC_PUBLIC | ACC_SUPER, "BadMethodref", null, "java/lang/Object", new String[]{"IBad"});
Handle handle1 =
new Handle(Opcodes.H_INVOKEINTERFACE, "BadMethodref", "m", "()V");
Handle handle2 =
new Handle(Opcodes.H_INVOKEINTERFACE, "BadMethodref", "staticM", "()V");
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "runm", "()V", null, null);
mv.visitCode();
// REF_invokeStatic
mv.visitLdcInsn(handle1);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandle", "invoke", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "runStaticM", "()V", null, null);
mv.visitCode();
// REF_invokeStatic
mv.visitLdcInsn(handle2);
mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandle", "invoke", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
static class CL extends ClassLoader {
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] classBytes = null;
switch (name) {
case "BadInterfaceMethodref": classBytes = dumpBadInterfaceMethodref(); break;
case "BadMethodref" : classBytes = dumpBadMethodref(); break;
case "IBad" : classBytes = dumpIBad(); break;
default : throw new ClassNotFoundException(name);
}
return defineClass(name, classBytes, 0, classBytes.length);
}
}
public static void main(String[] args) throws Throwable {
try (FileOutputStream fos = new FileOutputStream("BadInterfaceMethodref.class")) {
fos.write(dumpBadInterfaceMethodref());
}
try (FileOutputStream fos = new FileOutputStream("IBad.class")) {
fos.write(dumpIBad());
}
try (FileOutputStream fos = new FileOutputStream("BadMethodref.class")) {
fos.write(dumpBadMethodref());
}
Class<?> cls = (new CL()).loadClass("BadInterfaceMethodref");
String[] methods = {"runm", "runStaticM"};
System.out.println("Test BadInterfaceMethodref:");
int success = 0;
for (String name : methods) {
try {
System.out.printf("invoke %s: \n", name);
cls.getMethod(name).invoke(cls.newInstance());
System.out.println("FAILED - ICCE should be thrown");
} catch (Throwable e) {
if (e instanceof InvocationTargetException && e.getCause() != null &&
e.getCause() instanceof IncompatibleClassChangeError) {
System.out.println("PASSED - expected ICCE thrown");
success++;
continue;
} else {
System.out.println("FAILED with wrong exception" + e);
throw e;
}
}
}
if (success != methods.length) {
throw new Exception("BadInterfaceMethodRef Failed to catch IncompatibleClassChangeError");
}
System.out.println("Test BadMethodref:");
cls = (new CL()).loadClass("BadMethodref");
success = 0;
for (String name : methods) {
try {
System.out.printf("invoke %s: \n", name);
cls.getMethod(name).invoke(cls.newInstance());
System.out.println("FAILED - ICCE should be thrown");
} catch (Throwable e) {
if (e instanceof InvocationTargetException && e.getCause() != null &&
e.getCause() instanceof IncompatibleClassChangeError) {
System.out.println("PASSED - expected ICCE thrown");
success++;
continue;
} else {
System.out.println("FAILED with wrong exception" + e);
throw e;
}
}
}
if (success != methods.length) {
throw new Exception("BadMethodRef Failed to catch IncompatibleClassChangeError");
}
}
}

160
hotspot/test/runtime/ConstantPool/IntfMethod.java Normal file
View File

@ -0,0 +1,160 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* $bug 8087223
* @summary Adding constantTag to keep method call consistent with it.
* @library /testlibrary
* @modules java.base/jdk.internal.org.objectweb.asm
* java.base/jdk.internal.misc
* java.management
* @compile -XDignore.symbol.file IntfMethod.java
* @run main/othervm IntfMethod
* @run main/othervm -Xint IntfMethod
* @run main/othervm -Xcomp IntfMethod
*/
import jdk.internal.org.objectweb.asm.*;
import java.io.FileOutputStream;
import java.lang.reflect.InvocationTargetException;
import static jdk.internal.org.objectweb.asm.Opcodes.*;
public class IntfMethod {
static byte[] dumpC() {
ClassWriter cw = new ClassWriter(0);
cw.visit(52, ACC_PUBLIC | ACC_SUPER, "C", null, "java/lang/Object", new String[]{"I"});
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testSpecialIntf", "()V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "I", "f1", "()V", /*itf=*/false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testStaticIntf", "()V", null, null);
mv.visitCode();
mv.visitMethodInsn(INVOKESTATIC, "I", "f2", "()V", /*itf=*/false);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testSpecialClass", "()V", null, null);
mv.visitCode();
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "C", "f1", "()V", /*itf=*/true);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "f2", "()V", null, null);
mv.visitCode();
mv.visitInsn(RETURN);
mv.visitMaxs(0, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "testStaticClass", "()V", null, null);
mv.visitCode();
mv.visitMethodInsn(INVOKESTATIC, "C", "f2", "()V", /*itf=*/true);
mv.visitInsn(RETURN);
mv.visitMaxs(1, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
static byte[] dumpI() {
ClassWriter cw = new ClassWriter(0);
cw.visit(52, ACC_PUBLIC | ACC_ABSTRACT | ACC_INTERFACE, "I", null, "java/lang/Object", null);
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "f1", "()V", null, null);
mv.visitCode();
mv.visitInsn(RETURN);
mv.visitMaxs(0, 1);
mv.visitEnd();
}
{
MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "f2", "()V", null, null);
mv.visitCode();
mv.visitInsn(RETURN);
mv.visitMaxs(0, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
static class CL extends ClassLoader {
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] classFile;
switch (name) {
case "I": classFile = dumpI(); break;
case "C": classFile = dumpC(); break;
default:
throw new ClassNotFoundException(name);
}
return defineClass(name, classFile, 0, classFile.length);
}
}
public static void main(String[] args) throws Throwable {
Class<?> cls = (new CL()).loadClass("C");
try (FileOutputStream fos = new FileOutputStream("I.class")) { fos.write(dumpI()); }
try (FileOutputStream fos = new FileOutputStream("C.class")) { fos.write(dumpC()); }
int success = 0;
for (String name : new String[] { "testSpecialIntf", "testStaticIntf", "testSpecialClass", "testStaticClass"}) {
System.out.printf("%s: ", name);
try {
cls.getMethod(name).invoke(cls.newInstance());
System.out.println("FAILED - ICCE not thrown");
} catch (Throwable e) {
if (e instanceof InvocationTargetException &&
e.getCause() != null && e.getCause() instanceof IncompatibleClassChangeError) {
System.out.println("PASSED - expected ICCE thrown");
success++;
continue;
}
}
}
if (success != 4) throw new Exception("Failed to catch ICCE");
}
}

2
hotspot/test/runtime/SelectionResolution/classes/selectionresolution/Clazz.java
View File

@ -72,6 +72,6 @@ class Clazz extends ClassConstruct {
public Clazz(String name, String extending, int access, int classFileVersion, int index, String... implementing) {
super(name, extending == null ? "java/lang/Object" : extending, access + ACC_SUPER, classFileVersion, index, implementing);
// Add the default constructor
addMethod("<init>", "()V", ACC_PUBLIC).makeConstructor(extending);
addMethod("<init>", "()V", ACC_PUBLIC).makeConstructor(extending, false);
}
}

32
hotspot/test/runtime/SelectionResolution/classes/selectionresolution/Method.java
View File

@ -59,14 +59,12 @@ class Method {
private final String ownerClassName;
private final ClassVisitor cv;
private final MethodVisitor mv;
private final boolean isInterface;
private final ClassBuilder.ExecutionMode execMode;
public Method(ClassConstruct ownerClass, ClassVisitor cv, String name, String descriptor, int access,
ClassBuilder.ExecutionMode execMode) {
this.ownerClassName = ownerClass.getName();
this.ownerClass = ownerClass;
this.isInterface = ownerClass.isInterface();
this.execMode = execMode;
this.cv = cv;
mv = cv.visitMethod(access, name, descriptor, null, null);
@ -91,12 +89,12 @@ class Method {
public void makeSuperCallMethod(int invokeInstruction, String className) {
mv.visitVarInsn(ALOAD, 0);
makeCall(invokeInstruction, className);
makeCall(invokeInstruction, className, false);
mv.visitInsn(POP);
done();
}
public void defaultInvoke(int instr, String className, String objectRef) {
public void defaultInvoke(int instr, String className, String objectRef, boolean isInterface) {
switch (instr) {
case INVOKEVIRTUAL:
defaultInvokeVirtual(className, objectRef);
@ -105,10 +103,10 @@ class Method {
defaultInvokeInterface(className, objectRef);
break;
case INVOKESTATIC:
defaultInvokeStatic(className);
defaultInvokeStatic(className, isInterface);
break;
case INVOKESPECIAL:
defaultInvokeSpecial(className, objectRef);
defaultInvokeSpecial(className, objectRef, isInterface);
break;
default:
break;
@ -118,30 +116,26 @@ class Method {
mv.visitEnd();
}
public void defaultInvokeVirtual(String className, String objectRef) {
private void defaultInvokeVirtual(String className, String objectRef) {
String objectRefPackageName = objectRef.substring(0, objectRef.lastIndexOf("/"));
makeNewObject(objectRef, objectRefPackageName);
makeCall(INVOKEVIRTUAL, className, false);
}
public void defaultInvokeInterface(String className, String objectRef) {
private void defaultInvokeInterface(String className, String objectRef) {
String objectRefPackageName = objectRef.substring(0, objectRef.lastIndexOf("/"));
makeNewObject(objectRef, objectRefPackageName);
makeCall(INVOKEINTERFACE, className, true);
}
public void defaultInvokeSpecial(String className, String objectRef) {
private void defaultInvokeSpecial(String className, String objectRef, boolean isInterface) {
String objectRefPackageName = objectRef.substring(0, objectRef.lastIndexOf("/"));
makeNewObject(objectRef, objectRefPackageName);
makeCall(INVOKESPECIAL, className, false);
makeCall(INVOKESPECIAL, className, isInterface);
}
public void defaultInvokeStatic(String className) {
makeCall(INVOKESTATIC, className);
}
private Method makeCall(int invokeInstruction, String className) {
return makeCall(invokeInstruction, className, isInterface);
private void defaultInvokeStatic(String className, boolean isInterface) {
makeCall(INVOKESTATIC, className, isInterface);
}
private Method makeCall(int invokeInstruction, String className, boolean isInterface) {
@ -219,7 +213,7 @@ class Method {
String className = objectRef.substring(objectRef.lastIndexOf("/") + 1);
makeStaticCall( objectRefPackageName + "/Helper",
"get" + className,
"()L" + objectRef + ";");
"()L" + objectRef + ";", false);
mv.visitVarInsn(ASTORE, 1);
mv.visitVarInsn(ALOAD, 1);
}
@ -236,12 +230,12 @@ class Method {
mv.visitEnd();
}
public Method makeStaticCall(String classname, String method, String descriptor) {
public Method makeStaticCall(String classname, String method, String descriptor, boolean isInterface) {
mv.visitMethodInsn(INVOKESTATIC, classname, method, descriptor, isInterface);
return this;
}
public void makeConstructor(String extending) {
public void makeConstructor(String extending, boolean isInterface) {
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, extending == null ? "java/lang/Object" : extending, "<init>", "()V", isInterface);
mv.visitInsn(RETURN);

5
hotspot/test/runtime/SelectionResolution/classes/selectionresolution/TestBuilder.java
View File

@ -53,9 +53,10 @@ class TestBuilder extends Builder {
Method m = clazz.addMethod("test", "()Ljava/lang/Integer;", ACC_PUBLIC + ACC_STATIC, execMode);
m.defaultInvoke(getInvokeInstruction(testcase.invoke),
getName(testcase.methodref),
getName(testcase.objectref));
getName(testcase.objectref),
testcase.hier.isInterface(testcase.methodref));
mainMethod.makeStaticCall(clazz.getName(), "test", "()Ljava/lang/Integer;").done();
mainMethod.makeStaticCall(clazz.getName(), "test", "()Ljava/lang/Integer;", false).done();
}
private static int getInvokeInstruction(SelectionResolutionTestCase.InvokeInstruction instr) {