truffle: src/share/vm/classfile/verifier.cpp comparison

comparison src/share/vm/classfile/verifier.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	eaf39a954227 c2844108a708
children	be896a1983c0

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "prims/jvm.h"
 #include "runtime/fieldDescriptor.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/javaCalls.hpp"
-#include "runtime/orderAccess.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/os.hpp"
 #ifdef TARGET_ARCH_x86
 # include "bytes_x86.hpp"
 #endif
 #ifdef TARGET_ARCH_sparc
 no_control_flow = false; break;
 case Bytecodes::_invokevirtual :
 case Bytecodes::_invokespecial :
 case Bytecodes::_invokestatic :
 verify_invoke_instructions(
-&bcs, code_length, &current_frame,
+&bcs, code_length, &current_frame, (bci >= ex_min && bci < ex_max),
-&this_uninit, return_type, cp, CHECK_VERIFY(this));
+&this_uninit, return_type, cp, &stackmap_table, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_invokeinterface :
 case Bytecodes::_invokedynamic :
 verify_invoke_instructions(
-&bcs, code_length, &current_frame,
+&bcs, code_length, &current_frame, (bci >= ex_min && bci < ex_max),
-&this_uninit, return_type, cp, CHECK_VERIFY(this));
+&this_uninit, return_type, cp, &stackmap_table, CHECK_VERIFY(this));
 no_control_flow = false; break;
 case Bytecodes::_new :
 {
 index = bcs.get_index_u2();
 verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
 return false;
 }
 void ClassVerifier::verify_invoke_init(
 RawBytecodeStream* bcs, u2 ref_class_index, VerificationType ref_class_type,
-StackMapFrame* current_frame, u4 code_length, bool *this_uninit,
+StackMapFrame* current_frame, u4 code_length, bool in_try_block,
-constantPoolHandle cp, TRAPS) {
+bool *this_uninit, constantPoolHandle cp, StackMapTable* stackmap_table,
+TRAPS) {
 u2 bci = bcs->bci();
 VerificationType type = current_frame->pop_stack(
 VerificationType::reference_check(), CHECK_VERIFY(this));
 if (type == VerificationType::uninitialized_this_type()) {
 // The method must be an <init> method of this class or its superclass
 TypeOrigin::implicit(current_type())),
 "Bad <init> method call");
 return;
 }
-// Check if this call is done from inside of a TRY block.  If so, make
+// If this invokespecial call is done from inside of a TRY block then make
-// sure that all catch clause paths end in a throw.  Otherwise, this
+// sure that all catch clause paths end in a throw.  Otherwise, this can
-// can result in returning an incomplete object.
+// result in returning an incomplete object.
-ExceptionTable exhandlers(_method());
+if (in_try_block) {
-int exlength = exhandlers.length();
+ExceptionTable exhandlers(_method());
-for(int i = 0; i < exlength; i++) {
+int exlength = exhandlers.length();
-u2 start_pc = exhandlers.start_pc(i);
+for(int i = 0; i < exlength; i++) {
-u2 end_pc = exhandlers.end_pc(i);
+u2 start_pc = exhandlers.start_pc(i);
+u2 end_pc = exhandlers.end_pc(i);
-if (bci >= start_pc && bci < end_pc) {
-if (!ends_in_athrow(exhandlers.handler_pc(i))) {
+if (bci >= start_pc && bci < end_pc) {
-verify_error(ErrorContext::bad_code(bci),
+if (!ends_in_athrow(exhandlers.handler_pc(i))) {
-"Bad <init> method call from after the start of a try block");
+verify_error(ErrorContext::bad_code(bci),
-return;
+"Bad <init> method call from after the start of a try block");
-} else if (VerboseVerification) {
+return;
-ResourceMark rm;
+} else if (VerboseVerification) {
-tty->print_cr(
+ResourceMark rm;
-"Survived call to ends_in_athrow(): %s",
+tty->print_cr(
-current_class()->name()->as_C_string());
+"Survived call to ends_in_athrow(): %s",
+current_class()->name()->as_C_string());
+}
 }
 }
-}
+// Check the exception handler target stackmaps with the locals from the
+// incoming stackmap (before initialize_object() changes them to outgoing
+// state).
+verify_exception_handler_targets(bci, true, current_frame,
+stackmap_table, CHECK_VERIFY(this));
+} // in_try_block
 current_frame->initialize_object(type, current_type());
 *this_uninit = true;
 } else if (type.is_uninitialized()) {
 u2 new_offset = type.bci();
 return;
 }
 }
 }
 }
+// Check the exception handler target stackmaps with the locals from the
+// incoming stackmap (before initialize_object() changes them to outgoing
+// state).
+if (in_try_block) {
+verify_exception_handler_targets(bci, *this_uninit, current_frame,
+stackmap_table, CHECK_VERIFY(this));
+}
 current_frame->initialize_object(type, new_class_type);
 } else {
 verify_error(ErrorContext::bad_type(bci, current_frame->stack_top_ctx()),
 "Bad operand type when invoking <init>");
 return;
 return false;
 }
 void ClassVerifier::verify_invoke_instructions(
 RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
-bool *this_uninit, VerificationType return_type,
+bool in_try_block, bool *this_uninit, VerificationType return_type,
-constantPoolHandle cp, TRAPS) {
+constantPoolHandle cp, StackMapTable* stackmap_table, TRAPS) {
 // Make sure the constant pool item is the right type
 u2 index = bcs->get_index_u2();
 Bytecodes::Code opcode = bcs->raw_code();
 unsigned int types;
 switch (opcode) {
 // Check objectref on operand stack
 if (opcode != Bytecodes::_invokestatic &&
 opcode != Bytecodes::_invokedynamic) {
 if (method_name == vmSymbols::object_initializer_name()) {  // <init> method
 verify_invoke_init(bcs, index, ref_class_type, current_frame,
-code_length, this_uninit, cp, CHECK_VERIFY(this));
+code_length, in_try_block, this_uninit, cp, stackmap_table,
+CHECK_VERIFY(this));
 } else {   // other methods
 // Ensures that target class is assignable to method class.
 if (opcode == Bytecodes::_invokespecial) {
 if (!current_class()->is_anonymous()) {
 current_frame->pop_stack(current_type(), CHECK_VERIFY(this));

Mercurial > hg > truffle

comparison src/share/vm/classfile/verifier.cpp @ 20804:7848fc12602b