graal-jvmci-8: src/share/vm/interpreter/linkResolver.cpp comparison

comparison src/share/vm/interpreter/linkResolver.cpp @ 24170:0b85ccd62409 jdk8u131-b01

8168699: Validate special case invocations Reviewed-by: kevinw, vlivanov

author	coleenp
date	Tue, 13 Dec 2016 14:37:04 -0500
parents	81bed6c76a89
children	719853999215

comparison

equal deleted inserted replaced

-:5ee58c7d3938
+:0b85ccd62409
 /*
-* Copyright (c) 1997, 2014, 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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
 }
 }
-void LinkResolver::resolve_special_call(CallInfo& result, KlassHandle resolved_klass, Symbol* method_name,
+void LinkResolver::resolve_special_call(CallInfo& result, Handle recv, KlassHandle resolved_klass, Symbol* method_name,
 Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) {
 methodHandle resolved_method;
 linktime_resolve_special_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
-runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, check_access, CHECK);
+runtime_resolve_special_method(result, resolved_method, resolved_klass, current_klass, recv, check_access, CHECK);
 }
 // throws linktime exceptions
 void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method, KlassHandle resolved_klass,
 Symbol* method_name, Symbol* method_signature,
 }
 }
 // throws runtime exceptions
 void LinkResolver::runtime_resolve_special_method(CallInfo& result, methodHandle resolved_method, KlassHandle resolved_klass,
-KlassHandle current_klass, bool check_access, TRAPS) {
+KlassHandle current_klass, Handle recv, bool check_access, TRAPS) {
 // resolved method is selected method unless we have an old-style lookup
 // for a superclass method
 // Invokespecial for a superinterface, resolved method is selected method,
 // no checks for shadowing
 methodHandle sel_method(THREAD, resolved_method());
+if (check_access &&
+// check if the method is not <init>
+resolved_method->name() != vmSymbols::object_initializer_name()) {
 // check if this is an old-style super call and do a new lookup if so
-{ KlassHandle method_klass  = KlassHandle(THREAD,
-resolved_method->method_holder());
-if (check_access &&
 // a) check if ACC_SUPER flag is set for the current class
-(current_klass->is_super() || !AllowNonVirtualCalls) &&
+if ((current_klass->is_super() || !AllowNonVirtualCalls) &&
 // b) check if the class of the resolved_klass is a superclass
 // (not supertype in order to exclude interface classes) of the current class.
 // This check is not performed for super.invoke for interface methods
 // in super interfaces.
 current_klass->is_subclass_of(resolved_klass()) &&
-current_klass() != resolved_klass() &&
+current_klass() != resolved_klass()) {
-// c) check if the method is not <init>
-resolved_method->name() != vmSymbols::object_initializer_name()) {
 // Lookup super method
 KlassHandle super_klass(THREAD, current_klass->super());
 lookup_instance_method_in_klasses(sel_method, super_klass,
 resolved_method->name(),
 resolved_method->signature(), CHECK);
 ResourceMark rm(THREAD);
 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(),
 Method::name_and_sig_as_C_string(resolved_klass(),
 resolved_method->name(),
 resolved_method->signature()));
+}
+}
+// Check that the class of objectref (the receiver) is the current class or interface,
+// or a subtype of the current class or interface (the sender), otherwise invokespecial
+// throws IllegalAccessError.
+// The verifier checks that the sender is a subtype of the class in the I/MR operand.
+// The verifier also checks that the receiver is a subtype of the sender, if the sender is
+// a class.  If the sender is an interface, the check has to be performed at runtime.
+InstanceKlass* sender = InstanceKlass::cast(current_klass());
+sender = sender->is_anonymous() ? InstanceKlass::cast(sender->host_klass()) : sender;
+if (sender->is_interface() && recv.not_null()) {
+Klass* receiver_klass = recv->klass();
+if (!receiver_klass->is_subtype_of(sender)) {
+ResourceMark rm(THREAD);
+char buf[500];
+jio_snprintf(buf, sizeof(buf),
+"Receiver class %s must be the current class or a subtype of interface %s",
+receiver_klass->name()->as_C_string(),
+sender->name()->as_C_string());
+THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), buf);
 }
 }
 }
 // check if not static
 Symbol* signature,
 KlassHandle current_klass,
 bool check_access) {
 EXCEPTION_MARK;
 CallInfo info;
-resolve_special_call(info, resolved_klass, name, signature, current_klass, check_access, THREAD);
+resolve_special_call(info, Handle(), resolved_klass, name, signature, current_klass, check_access, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
 return methodHandle();
 }
 return info.selected_method();
 // ConstantPool entries
 void LinkResolver::resolve_invoke(CallInfo& result, Handle recv, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) {
 switch (byte) {
 case Bytecodes::_invokestatic   : resolve_invokestatic   (result,       pool, index, CHECK); break;
-case Bytecodes::_invokespecial  : resolve_invokespecial  (result,       pool, index, CHECK); break;
+case Bytecodes::_invokespecial  : resolve_invokespecial  (result, recv, pool, index, CHECK); break;
 case Bytecodes::_invokevirtual  : resolve_invokevirtual  (result, recv, pool, index, CHECK); break;
 case Bytecodes::_invokehandle   : resolve_invokehandle   (result,       pool, index, CHECK); break;
 case Bytecodes::_invokedynamic  : resolve_invokedynamic  (result,       pool, index, CHECK); break;
 case Bytecodes::_invokeinterface: resolve_invokeinterface(result, recv, pool, index, CHECK); break;
 }
 resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
 resolve_static_call(result, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
 }
-void LinkResolver::resolve_invokespecial(CallInfo& result, constantPoolHandle pool, int index, TRAPS) {
+void LinkResolver::resolve_invokespecial(CallInfo& result, Handle recv, constantPoolHandle pool, int index, TRAPS) {
 KlassHandle  resolved_klass;
 Symbol* method_name = NULL;
 Symbol* method_signature = NULL;
 KlassHandle  current_klass;
 resolve_pool(resolved_klass, method_name,  method_signature, current_klass, pool, index, CHECK);
-resolve_special_call(result, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
+resolve_special_call(result, recv, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
 }
 void LinkResolver::resolve_invokevirtual(CallInfo& result, Handle recv,
 constantPoolHandle pool, int index,

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/interpreter/linkResolver.cpp @ 24170:0b85ccd62409 jdk8u131-b01