< prev index next >

src/hotspot/share/classfile/verifier.cpp

Print this page




2769 
2770   if (opcode == Bytecodes::_invokedynamic) {
2771     address bcp = bcs->bcp();
2772     if (*(bcp+3) != 0 || *(bcp+4) != 0) {
2773       verify_error(ErrorContext::bad_code(bci),
2774           "Third and fourth operand bytes of invokedynamic must be zero");
2775       return;
2776     }
2777   }
2778 
2779   if (method_name->byte_at(0) == '<') {
2780     // Make sure <init> can only be invoked by invokespecial
2781     if (opcode != Bytecodes::_invokespecial ||
2782         method_name != vmSymbols::object_initializer_name()) {
2783       verify_error(ErrorContext::bad_code(bci),
2784           "Illegal call to internal method");
2785       return;
2786     }
2787   } else if (opcode == Bytecodes::_invokespecial
2788              && !is_same_or_direct_interface(current_class(), current_type(), ref_class_type)
2789              && !ref_class_type.equals(VerificationType::reference_type(current_class()->super()->name()))) {

2790      bool subtype = false;
2791      bool have_imr_indirect = cp->tag_at(index).value() == JVM_CONSTANT_InterfaceMethodref;
2792      if (!current_class()->is_anonymous()) {
2793        subtype = ref_class_type.is_assignable_from(current_type(), this, false, CHECK_VERIFY(this));

2794      } else {
2795        VerificationType host_klass_type =
2796            VerificationType::reference_type(current_class()->host_klass()->name());
2797        subtype = ref_class_type.is_assignable_from(host_klass_type, this, false, CHECK_VERIFY(this));
2798 
2799        // If invokespecial of IMR, need to recheck for same or
2800        // direct interface relative to the host class
2801        have_imr_indirect = (have_imr_indirect &&
2802                             !is_same_or_direct_interface(current_class()->host_klass(),

2803                                                          host_klass_type, ref_class_type));
2804      }
2805      if (!subtype) {
2806        verify_error(ErrorContext::bad_code(bci),
2807                     "Bad invokespecial instruction: "
2808                     "current class isn't assignable to reference class.");
2809         return;
2810      } else if (have_imr_indirect) {
2811        verify_error(ErrorContext::bad_code(bci),
2812                     "Bad invokespecial instruction: "
2813                     "interface method reference is in an indirect superinterface.");
2814        return;
2815      }
2816   }
2817 

2818   // Match method descriptor with operand stack
2819   for (int i = nargs - 1; i >= 0; i--) {  // Run backwards
2820     current_frame->pop_stack(sig_types[i], CHECK_VERIFY(this));
2821   }
2822   // Check objectref on operand stack
2823   if (opcode != Bytecodes::_invokestatic &&
2824       opcode != Bytecodes::_invokedynamic) {
2825     if (method_name == vmSymbols::object_initializer_name()) {  // <init> method
2826       verify_invoke_init(bcs, index, ref_class_type, current_frame,
2827         code_length, in_try_block, this_uninit, cp, stackmap_table,
2828         CHECK_VERIFY(this));
2829       if (was_recursively_verified()) return;
2830     } else {   // other methods
2831       // Ensures that target class is assignable to current class (4.9.2)
2832       if (opcode == Bytecodes::_invokespecial) {
2833         if (!current_class()->is_anonymous()) {
2834           current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
2835         } else {
2836           // anonymous class invokespecial calls: check if the
2837           // objectref is a subtype of the host_klass of the current class
2838           // to allow an anonymous class to reference methods in the host_klass
2839           VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
2840           VerificationType hosttype =
2841             VerificationType::reference_type(current_class()->host_klass()->name());
2842           bool subtype = hosttype.is_assignable_from(top, this, false, CHECK_VERIFY(this));
2843           if (!subtype) {
2844             verify_error(ErrorContext::bad_type(current_frame->offset(),
2845                                                 current_frame->stack_top_ctx(),
2846                                                 TypeOrigin::implicit(top)),
2847                          "Bad type on operand stack");
2848             return;
2849           }
2850         }
2851       } else if (opcode == Bytecodes::_invokevirtual) {
2852         VerificationType stack_object_type =
2853           current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
2854         if (current_type() != stack_object_type) {
2855           if (was_recursively_verified()) return;
2856           assert(cp->cache() == NULL, "not rewritten yet");
2857           Symbol* ref_class_name =
2858             cp->klass_name_at(cp->klass_ref_index_at(index));
2859           // See the comments in verify_field_instructions() for
2860           // the rationale behind this.
2861           if (name_in_supers(ref_class_name, current_class())) {
2862             Klass* ref_class = load_class(ref_class_name, CHECK);
2863             if (is_protected_access(
2864                   _klass, ref_class, method_name, method_sig, true)) {




2769 
2770   if (opcode == Bytecodes::_invokedynamic) {
2771     address bcp = bcs->bcp();
2772     if (*(bcp+3) != 0 || *(bcp+4) != 0) {
2773       verify_error(ErrorContext::bad_code(bci),
2774           "Third and fourth operand bytes of invokedynamic must be zero");
2775       return;
2776     }
2777   }
2778 
2779   if (method_name->byte_at(0) == '<') {
2780     // Make sure <init> can only be invoked by invokespecial
2781     if (opcode != Bytecodes::_invokespecial ||
2782         method_name != vmSymbols::object_initializer_name()) {
2783       verify_error(ErrorContext::bad_code(bci),
2784           "Illegal call to internal method");
2785       return;
2786     }
2787   } else if (opcode == Bytecodes::_invokespecial
2788              && !is_same_or_direct_interface(current_class(), current_type(), ref_class_type)
2789              && !ref_class_type.equals(VerificationType::reference_type(
2790                   current_class()->super()->name()))) {
2791     bool subtype = false;
2792     bool have_imr_indirect = cp->tag_at(index).value() == JVM_CONSTANT_InterfaceMethodref;
2793     if (!current_class()->is_anonymous()) {
2794       subtype = ref_class_type.is_assignable_from(
2795                  current_type(), this, false, CHECK_VERIFY(this));
2796     } else {
2797       VerificationType host_klass_type =
2798                         VerificationType::reference_type(current_class()->host_klass()->name());
2799       subtype = ref_class_type.is_assignable_from(host_klass_type, this, false, CHECK_VERIFY(this));
2800 
2801       // If invokespecial of IMR, need to recheck for same or
2802       // direct interface relative to the host class
2803       have_imr_indirect = (have_imr_indirect &&
2804                            !is_same_or_direct_interface(
2805                              current_class()->host_klass(),
2806                              host_klass_type, ref_class_type));
2807     }
2808     if (!subtype) {
2809       verify_error(ErrorContext::bad_code(bci),
2810           "Bad invokespecial instruction: "
2811           "current class isn't assignable to reference class.");
2812        return;
2813     } else if (have_imr_indirect) {
2814       verify_error(ErrorContext::bad_code(bci),
2815           "Bad invokespecial instruction: "
2816           "interface method reference is in an indirect superinterface.");
2817       return;
2818     }

2819 
2820   }
2821   // Match method descriptor with operand stack
2822   for (int i = nargs - 1; i >= 0; i--) {  // Run backwards
2823     current_frame->pop_stack(sig_types[i], CHECK_VERIFY(this));
2824   }
2825   // Check objectref on operand stack
2826   if (opcode != Bytecodes::_invokestatic &&
2827       opcode != Bytecodes::_invokedynamic) {
2828     if (method_name == vmSymbols::object_initializer_name()) {  // <init> method
2829       verify_invoke_init(bcs, index, ref_class_type, current_frame,
2830         code_length, in_try_block, this_uninit, cp, stackmap_table,
2831         CHECK_VERIFY(this));
2832       if (was_recursively_verified()) return;
2833     } else {   // other methods
2834       // Ensures that target class is assignable to method class.
2835       if (opcode == Bytecodes::_invokespecial) {
2836         if (!current_class()->is_anonymous()) {
2837           current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
2838         } else {
2839           // anonymous class invokespecial calls: check if the
2840           // objectref is a subtype of the host_klass of the current class
2841           // to allow an anonymous class to reference methods in the host_klass
2842           VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
2843           VerificationType hosttype =
2844             VerificationType::reference_type(current_class()->host_klass()->name());
2845           bool subtype = hosttype.is_assignable_from(top, this, false, CHECK_VERIFY(this));
2846           if (!subtype) {
2847             verify_error( ErrorContext::bad_type(current_frame->offset(),
2848               current_frame->stack_top_ctx(),
2849               TypeOrigin::implicit(top)),
2850               "Bad type on operand stack");
2851             return;
2852           }
2853         }
2854       } else if (opcode == Bytecodes::_invokevirtual) {
2855         VerificationType stack_object_type =
2856           current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
2857         if (current_type() != stack_object_type) {
2858           if (was_recursively_verified()) return;
2859           assert(cp->cache() == NULL, "not rewritten yet");
2860           Symbol* ref_class_name =
2861             cp->klass_name_at(cp->klass_ref_index_at(index));
2862           // See the comments in verify_field_instructions() for
2863           // the rationale behind this.
2864           if (name_in_supers(ref_class_name, current_class())) {
2865             Klass* ref_class = load_class(ref_class_name, CHECK);
2866             if (is_protected_access(
2867                   _klass, ref_class, method_name, method_sig, true)) {


< prev index next >