1662 VerificationType::double2_type(), CHECK_VERIFY(this));
1663 type = current_frame.pop_stack(
1664 VerificationType::double_type(), CHECK_VERIFY(this));
1665 verify_return_value(return_type, type, bci,
1666 ¤t_frame, CHECK_VERIFY(this));
1667 no_control_flow = true; break;
1668 case Bytecodes::_areturn :
1669 type = current_frame.pop_stack(
1670 VerificationType::nonscalar_check(), CHECK_VERIFY(this));
1671 verify_return_value(return_type, type, bci,
1672 ¤t_frame, CHECK_VERIFY(this));
1673 no_control_flow = true; break;
1674 case Bytecodes::_return :
1675 if (return_type != VerificationType::bogus_type()) {
1676 verify_error(ErrorContext::bad_code(bci),
1677 "Method expects a return value");
1678 return;
1679 }
1680 // Make sure "this" has been initialized if current method is an
1681 // <init>.
1682 if (_method->name() == vmSymbols::object_initializer_name() &&
1683 current_frame.flag_this_uninit()) {
1684 verify_error(ErrorContext::bad_code(bci),
1685 "Constructor must call super() or this() "
1686 "before return");
1687 return;
1688 }
1689 no_control_flow = true; break;
1690 case Bytecodes::_getstatic :
1691 case Bytecodes::_putstatic :
1692 // pass TRUE, operand can be an array type for getstatic/putstatic.
1693 verify_field_instructions(
1694 &bcs, ¤t_frame, cp, true, CHECK_VERIFY(this));
1695 no_control_flow = false; break;
1696 case Bytecodes::_getfield :
1697 case Bytecodes::_putfield :
1698 // pass FALSE, operand can't be an array type for getfield/putfield.
1699 verify_field_instructions(
1700 &bcs, ¤t_frame, cp, false, CHECK_VERIFY(this));
1701 no_control_flow = false; break;
1702 case Bytecodes::_withfield :
1703 if (_klass->major_version() < VALUETYPE_MAJOR_VERSION) {
1704 class_format_error(
1705 "withfield not supported by this class file version (%d.%d), class %s",
1706 _klass->major_version(), _klass->minor_version(), _klass->external_name());
1707 return;
1708 }
1709 // pass FALSE, operand can't be an array type for withfield.
1710 verify_field_instructions(
1711 &bcs, ¤t_frame, cp, false, CHECK_VERIFY(this));
1712 no_control_flow = false; break;
1713 case Bytecodes::_invokevirtual :
1714 case Bytecodes::_invokespecial :
1715 case Bytecodes::_invokestatic :
1716 verify_invoke_instructions(
1717 &bcs, code_length, ¤t_frame, (bci >= ex_min && bci < ex_max),
1718 &this_uninit, return_type, cp, &stackmap_table, CHECK_VERIFY(this));
1719 no_control_flow = false; break;
1720 case Bytecodes::_invokeinterface :
1721 case Bytecodes::_invokedynamic :
1722 verify_invoke_instructions(
1723 &bcs, code_length, ¤t_frame, (bci >= ex_min && bci < ex_max),
1724 &this_uninit, return_type, cp, &stackmap_table, CHECK_VERIFY(this));
1725 no_control_flow = false; break;
1726 case Bytecodes::_new :
1727 {
1728 index = bcs.get_index_u2();
1729 verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1730 VerificationType new_class_type =
1731 cp_index_to_type(index, cp, CHECK_VERIFY(this));
1732 if (!new_class_type.is_object()) {
1733 verify_error(ErrorContext::bad_type(bci,
1734 TypeOrigin::cp(index, new_class_type)),
1735 "Illegal new instruction");
1736 return;
1737 }
1738 type = VerificationType::uninitialized_type(bci);
1739 current_frame.push_stack(type, CHECK_VERIFY(this));
1740 no_control_flow = false; break;
1741 }
1742 case Bytecodes::_defaultvalue :
1743 {
1744 if (_klass->major_version() < VALUETYPE_MAJOR_VERSION) {
2802 bool ClassVerifier::is_same_or_direct_interface(
2803 InstanceKlass* klass,
2804 VerificationType klass_type,
2805 VerificationType ref_class_type) {
2806 if (ref_class_type.equals(klass_type)) return true;
2807 Array<InstanceKlass*>* local_interfaces = klass->local_interfaces();
2808 if (local_interfaces != NULL) {
2809 for (int x = 0; x < local_interfaces->length(); x++) {
2810 InstanceKlass* k = local_interfaces->at(x);
2811 assert (k != NULL && k->is_interface(), "invalid interface");
2812 if (ref_class_type.equals(VerificationType::reference_type(k->name()))) {
2813 return true;
2814 }
2815 }
2816 }
2817 return false;
2818 }
2819
2820 void ClassVerifier::verify_invoke_instructions(
2821 RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
2822 bool in_try_block, bool *this_uninit, VerificationType return_type,
2823 const constantPoolHandle& cp, StackMapTable* stackmap_table, TRAPS) {
2824 // Make sure the constant pool item is the right type
2825 u2 index = bcs->get_index_u2();
2826 Bytecodes::Code opcode = bcs->raw_code();
2827 unsigned int types = 0;
2828 switch (opcode) {
2829 case Bytecodes::_invokeinterface:
2830 types = 1 << JVM_CONSTANT_InterfaceMethodref;
2831 break;
2832 case Bytecodes::_invokedynamic:
2833 types = 1 << JVM_CONSTANT_InvokeDynamic;
2834 break;
2835 case Bytecodes::_invokespecial:
2836 case Bytecodes::_invokestatic:
2837 types = (_klass->major_version() < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) ?
2838 (1 << JVM_CONSTANT_Methodref) :
2839 ((1 << JVM_CONSTANT_InterfaceMethodref) | (1 << JVM_CONSTANT_Methodref));
2840 break;
2841 default:
2842 types = 1 << JVM_CONSTANT_Methodref;
2900 "Inconsistent args count operand in invokeinterface");
2901 return;
2902 }
2903 if (*(bcp+4) != 0) {
2904 verify_error(ErrorContext::bad_code(bci),
2905 "Fourth operand byte of invokeinterface must be zero");
2906 return;
2907 }
2908 }
2909
2910 if (opcode == Bytecodes::_invokedynamic) {
2911 address bcp = bcs->bcp();
2912 if (*(bcp+3) != 0 || *(bcp+4) != 0) {
2913 verify_error(ErrorContext::bad_code(bci),
2914 "Third and fourth operand bytes of invokedynamic must be zero");
2915 return;
2916 }
2917 }
2918
2919 if (method_name->char_at(0) == '<') {
2920 // Make sure <init> can only be invoked by invokespecial
2921 if (opcode != Bytecodes::_invokespecial ||
2922 method_name != vmSymbols::object_initializer_name()) {
2923 verify_error(ErrorContext::bad_code(bci),
2924 "Illegal call to internal method");
2925 return;
2926 }
2927 } else if (opcode == Bytecodes::_invokespecial
2928 && !is_same_or_direct_interface(current_class(), current_type(), ref_class_type)
2929 && !ref_class_type.equals(VerificationType::reference_type(
2930 current_class()->super()->name()))) { // super() can never be a value_type.
2931 bool subtype = false;
2932 bool have_imr_indirect = cp->tag_at(index).value() == JVM_CONSTANT_InterfaceMethodref;
2933 if (!current_class()->is_unsafe_anonymous()) {
2934 subtype = ref_class_type.is_assignable_from(
2935 current_type(), this, false, CHECK_VERIFY(this));
2936 } else {
2937 InstanceKlass* unsafe_host = current_class()->unsafe_anonymous_host();
2938 VerificationType unsafe_anonymous_host_type = reference_or_valuetype(unsafe_host);
2939 subtype = ref_class_type.is_assignable_from(unsafe_anonymous_host_type, this, false, CHECK_VERIFY(this));
2940
2941 // If invokespecial of IMR, need to recheck for same or
2955 "Bad invokespecial instruction: "
2956 "interface method reference is in an indirect superinterface.");
2957 return;
2958 }
2959
2960 }
2961
2962 // Get the verification types for the method's arguments.
2963 GrowableArray<VerificationType>* sig_verif_types = mth_sig_verif_types->sig_verif_types();
2964 assert(sig_verif_types != NULL, "Missing signature's array of verification types");
2965 // Match method descriptor with operand stack
2966 // The arguments are on the stack in descending order.
2967 for (int i = nargs - 1; i >= 0; i--) { // Run backwards
2968 current_frame->pop_stack(sig_verif_types->at(i), CHECK_VERIFY(this));
2969 }
2970
2971 // Check objectref on operand stack
2972 if (opcode != Bytecodes::_invokestatic &&
2973 opcode != Bytecodes::_invokedynamic) {
2974 if (method_name == vmSymbols::object_initializer_name()) { // <init> method
2975 verify_invoke_init(bcs, index, ref_class_type, current_frame,
2976 code_length, in_try_block, this_uninit, cp, stackmap_table,
2977 CHECK_VERIFY(this));
2978 if (was_recursively_verified()) return;
2979 } else { // other methods
2980 // Ensures that target class is assignable to method class.
2981 if (opcode == Bytecodes::_invokespecial) {
2982 if (!current_class()->is_unsafe_anonymous()) {
2983 current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
2984 } else {
2985 // anonymous class invokespecial calls: check if the
2986 // objectref is a subtype of the unsafe_anonymous_host of the current class
2987 // to allow an anonymous class to reference methods in the unsafe_anonymous_host
2988 VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
2989
2990 InstanceKlass* unsafe_host = current_class()->unsafe_anonymous_host();
2991 VerificationType host_type = reference_or_valuetype(unsafe_host);
2992 bool subtype = host_type.is_assignable_from(top, this, false, CHECK_VERIFY(this));
2993 if (!subtype) {
2994 verify_error( ErrorContext::bad_type(current_frame->offset(),
3025 } else {
3026 verify_error(ErrorContext::bad_type(bci,
3027 current_frame->stack_top_ctx(),
3028 TypeOrigin::implicit(current_type())),
3029 "Bad access to protected data in invokevirtual");
3030 return;
3031 }
3032 }
3033 }
3034 }
3035 }
3036 } else {
3037 assert(opcode == Bytecodes::_invokeinterface, "Unexpected opcode encountered");
3038 current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
3039 }
3040 }
3041 }
3042 // Push the result type.
3043 int sig_verif_types_len = sig_verif_types->length();
3044 if (sig_verif_types_len > nargs) { // There's a return type
3045 if (method_name == vmSymbols::object_initializer_name()) {
3046 // <init> method must have a void return type
3047 /* Unreachable? Class file parser verifies that methods with '<' have
3048 * void return */
3049 verify_error(ErrorContext::bad_code(bci),
3050 "Return type must be void in <init> method");
3051 return;
3052 }
3053
3054 assert(sig_verif_types_len <= nargs + 2,
3055 "Signature verification types array return type is bogus");
3056 for (int i = nargs; i < sig_verif_types_len; i++) {
3057 assert(i == nargs || sig_verif_types->at(i).is_long2() ||
3058 sig_verif_types->at(i).is_double2(), "Unexpected return verificationType");
3059 current_frame->push_stack(sig_verif_types->at(i), CHECK_VERIFY(this));
3060 }
3061 }
3062 }
3063
3064 VerificationType ClassVerifier::get_newarray_type(
3065 u2 index, u2 bci, TRAPS) {
3066 const char* from_bt[] = {
3067 NULL, NULL, NULL, NULL, "[Z", "[C", "[F", "[D", "[B", "[S", "[I", "[J",
3068 };
3069 if (index < T_BOOLEAN || index > T_LONG) {
3070 verify_error(ErrorContext::bad_code(bci), "Illegal newarray instruction");
3071 return VerificationType::bogus_type();
3072 }
3073
3074 // from_bt[index] contains the array signature which has a length of 2
3075 Symbol* sig = create_temporary_symbol(
3076 from_bt[index], 2, CHECK_(VerificationType::bogus_type()));
3077 return VerificationType::reference_type(sig);
3078 }
3079
3080 void ClassVerifier::verify_anewarray(
|
1662 VerificationType::double2_type(), CHECK_VERIFY(this));
1663 type = current_frame.pop_stack(
1664 VerificationType::double_type(), CHECK_VERIFY(this));
1665 verify_return_value(return_type, type, bci,
1666 ¤t_frame, CHECK_VERIFY(this));
1667 no_control_flow = true; break;
1668 case Bytecodes::_areturn :
1669 type = current_frame.pop_stack(
1670 VerificationType::nonscalar_check(), CHECK_VERIFY(this));
1671 verify_return_value(return_type, type, bci,
1672 ¤t_frame, CHECK_VERIFY(this));
1673 no_control_flow = true; break;
1674 case Bytecodes::_return :
1675 if (return_type != VerificationType::bogus_type()) {
1676 verify_error(ErrorContext::bad_code(bci),
1677 "Method expects a return value");
1678 return;
1679 }
1680 // Make sure "this" has been initialized if current method is an
1681 // <init>.
1682 if (_method->is_object_constructor() &&
1683 current_frame.flag_this_uninit()) {
1684 verify_error(ErrorContext::bad_code(bci),
1685 "Constructor must call super() or this() "
1686 "before return");
1687 return;
1688 }
1689 no_control_flow = true; break;
1690 case Bytecodes::_getstatic :
1691 case Bytecodes::_putstatic :
1692 // pass TRUE, operand can be an array type for getstatic/putstatic.
1693 verify_field_instructions(
1694 &bcs, ¤t_frame, cp, true, CHECK_VERIFY(this));
1695 no_control_flow = false; break;
1696 case Bytecodes::_getfield :
1697 case Bytecodes::_putfield :
1698 // pass FALSE, operand can't be an array type for getfield/putfield.
1699 verify_field_instructions(
1700 &bcs, ¤t_frame, cp, false, CHECK_VERIFY(this));
1701 no_control_flow = false; break;
1702 case Bytecodes::_withfield :
1703 if (_klass->major_version() < VALUETYPE_MAJOR_VERSION) {
1704 class_format_error(
1705 "withfield not supported by this class file version (%d.%d), class %s",
1706 _klass->major_version(), _klass->minor_version(), _klass->external_name());
1707 return;
1708 }
1709 // pass FALSE, operand can't be an array type for withfield.
1710 verify_field_instructions(
1711 &bcs, ¤t_frame, cp, false, CHECK_VERIFY(this));
1712 no_control_flow = false; break;
1713 case Bytecodes::_invokevirtual :
1714 case Bytecodes::_invokespecial :
1715 case Bytecodes::_invokestatic :
1716 verify_invoke_instructions(
1717 &bcs, code_length, ¤t_frame, (bci >= ex_min && bci < ex_max),
1718 &this_uninit, cp, &stackmap_table, CHECK_VERIFY(this));
1719 no_control_flow = false; break;
1720 case Bytecodes::_invokeinterface :
1721 case Bytecodes::_invokedynamic :
1722 verify_invoke_instructions(
1723 &bcs, code_length, ¤t_frame, (bci >= ex_min && bci < ex_max),
1724 &this_uninit, cp, &stackmap_table, CHECK_VERIFY(this));
1725 no_control_flow = false; break;
1726 case Bytecodes::_new :
1727 {
1728 index = bcs.get_index_u2();
1729 verify_cp_class_type(bci, index, cp, CHECK_VERIFY(this));
1730 VerificationType new_class_type =
1731 cp_index_to_type(index, cp, CHECK_VERIFY(this));
1732 if (!new_class_type.is_object()) {
1733 verify_error(ErrorContext::bad_type(bci,
1734 TypeOrigin::cp(index, new_class_type)),
1735 "Illegal new instruction");
1736 return;
1737 }
1738 type = VerificationType::uninitialized_type(bci);
1739 current_frame.push_stack(type, CHECK_VERIFY(this));
1740 no_control_flow = false; break;
1741 }
1742 case Bytecodes::_defaultvalue :
1743 {
1744 if (_klass->major_version() < VALUETYPE_MAJOR_VERSION) {
2802 bool ClassVerifier::is_same_or_direct_interface(
2803 InstanceKlass* klass,
2804 VerificationType klass_type,
2805 VerificationType ref_class_type) {
2806 if (ref_class_type.equals(klass_type)) return true;
2807 Array<InstanceKlass*>* local_interfaces = klass->local_interfaces();
2808 if (local_interfaces != NULL) {
2809 for (int x = 0; x < local_interfaces->length(); x++) {
2810 InstanceKlass* k = local_interfaces->at(x);
2811 assert (k != NULL && k->is_interface(), "invalid interface");
2812 if (ref_class_type.equals(VerificationType::reference_type(k->name()))) {
2813 return true;
2814 }
2815 }
2816 }
2817 return false;
2818 }
2819
2820 void ClassVerifier::verify_invoke_instructions(
2821 RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
2822 bool in_try_block, bool *this_uninit,
2823 const constantPoolHandle& cp, StackMapTable* stackmap_table, TRAPS) {
2824 // Make sure the constant pool item is the right type
2825 u2 index = bcs->get_index_u2();
2826 Bytecodes::Code opcode = bcs->raw_code();
2827 unsigned int types = 0;
2828 switch (opcode) {
2829 case Bytecodes::_invokeinterface:
2830 types = 1 << JVM_CONSTANT_InterfaceMethodref;
2831 break;
2832 case Bytecodes::_invokedynamic:
2833 types = 1 << JVM_CONSTANT_InvokeDynamic;
2834 break;
2835 case Bytecodes::_invokespecial:
2836 case Bytecodes::_invokestatic:
2837 types = (_klass->major_version() < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) ?
2838 (1 << JVM_CONSTANT_Methodref) :
2839 ((1 << JVM_CONSTANT_InterfaceMethodref) | (1 << JVM_CONSTANT_Methodref));
2840 break;
2841 default:
2842 types = 1 << JVM_CONSTANT_Methodref;
2900 "Inconsistent args count operand in invokeinterface");
2901 return;
2902 }
2903 if (*(bcp+4) != 0) {
2904 verify_error(ErrorContext::bad_code(bci),
2905 "Fourth operand byte of invokeinterface must be zero");
2906 return;
2907 }
2908 }
2909
2910 if (opcode == Bytecodes::_invokedynamic) {
2911 address bcp = bcs->bcp();
2912 if (*(bcp+3) != 0 || *(bcp+4) != 0) {
2913 verify_error(ErrorContext::bad_code(bci),
2914 "Third and fourth operand bytes of invokedynamic must be zero");
2915 return;
2916 }
2917 }
2918
2919 if (method_name->char_at(0) == '<') {
2920 // Make sure <init> can only be invoked by invokespecial or invokestatic.
2921 // The allowed invocation mode of <init> depends on its signature.
2922 if ((opcode != Bytecodes::_invokespecial &&
2923 opcode != Bytecodes::_invokestatic) ||
2924 method_name != vmSymbols::object_initializer_name()) {
2925 verify_error(ErrorContext::bad_code(bci),
2926 "Illegal call to internal method");
2927 return;
2928 }
2929 } else if (opcode == Bytecodes::_invokespecial
2930 && !is_same_or_direct_interface(current_class(), current_type(), ref_class_type)
2931 && !ref_class_type.equals(VerificationType::reference_type(
2932 current_class()->super()->name()))) { // super() can never be a value_type.
2933 bool subtype = false;
2934 bool have_imr_indirect = cp->tag_at(index).value() == JVM_CONSTANT_InterfaceMethodref;
2935 if (!current_class()->is_unsafe_anonymous()) {
2936 subtype = ref_class_type.is_assignable_from(
2937 current_type(), this, false, CHECK_VERIFY(this));
2938 } else {
2939 InstanceKlass* unsafe_host = current_class()->unsafe_anonymous_host();
2940 VerificationType unsafe_anonymous_host_type = reference_or_valuetype(unsafe_host);
2941 subtype = ref_class_type.is_assignable_from(unsafe_anonymous_host_type, this, false, CHECK_VERIFY(this));
2942
2943 // If invokespecial of IMR, need to recheck for same or
2957 "Bad invokespecial instruction: "
2958 "interface method reference is in an indirect superinterface.");
2959 return;
2960 }
2961
2962 }
2963
2964 // Get the verification types for the method's arguments.
2965 GrowableArray<VerificationType>* sig_verif_types = mth_sig_verif_types->sig_verif_types();
2966 assert(sig_verif_types != NULL, "Missing signature's array of verification types");
2967 // Match method descriptor with operand stack
2968 // The arguments are on the stack in descending order.
2969 for (int i = nargs - 1; i >= 0; i--) { // Run backwards
2970 current_frame->pop_stack(sig_verif_types->at(i), CHECK_VERIFY(this));
2971 }
2972
2973 // Check objectref on operand stack
2974 if (opcode != Bytecodes::_invokestatic &&
2975 opcode != Bytecodes::_invokedynamic) {
2976 if (method_name == vmSymbols::object_initializer_name()) { // <init> method
2977 // (use of <init> as a static factory is handled under invokestatic)
2978 verify_invoke_init(bcs, index, ref_class_type, current_frame,
2979 code_length, in_try_block, this_uninit, cp, stackmap_table,
2980 CHECK_VERIFY(this));
2981 if (was_recursively_verified()) return;
2982 } else { // other methods
2983 // Ensures that target class is assignable to method class.
2984 if (opcode == Bytecodes::_invokespecial) {
2985 if (!current_class()->is_unsafe_anonymous()) {
2986 current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
2987 } else {
2988 // anonymous class invokespecial calls: check if the
2989 // objectref is a subtype of the unsafe_anonymous_host of the current class
2990 // to allow an anonymous class to reference methods in the unsafe_anonymous_host
2991 VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
2992
2993 InstanceKlass* unsafe_host = current_class()->unsafe_anonymous_host();
2994 VerificationType host_type = reference_or_valuetype(unsafe_host);
2995 bool subtype = host_type.is_assignable_from(top, this, false, CHECK_VERIFY(this));
2996 if (!subtype) {
2997 verify_error( ErrorContext::bad_type(current_frame->offset(),
3028 } else {
3029 verify_error(ErrorContext::bad_type(bci,
3030 current_frame->stack_top_ctx(),
3031 TypeOrigin::implicit(current_type())),
3032 "Bad access to protected data in invokevirtual");
3033 return;
3034 }
3035 }
3036 }
3037 }
3038 }
3039 } else {
3040 assert(opcode == Bytecodes::_invokeinterface, "Unexpected opcode encountered");
3041 current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
3042 }
3043 }
3044 }
3045 // Push the result type.
3046 int sig_verif_types_len = sig_verif_types->length();
3047 if (sig_verif_types_len > nargs) { // There's a return type
3048 if (method_name == vmSymbols::object_initializer_name() &&
3049 opcode != Bytecodes::_invokestatic) {
3050 // an <init> method must have a void return type, unless it's a static factory
3051 verify_error(ErrorContext::bad_code(bci),
3052 "Return type must be void in <init> method");
3053 return;
3054 }
3055
3056 assert(sig_verif_types_len <= nargs + 2,
3057 "Signature verification types array return type is bogus");
3058 for (int i = nargs; i < sig_verif_types_len; i++) {
3059 assert(i == nargs || sig_verif_types->at(i).is_long2() ||
3060 sig_verif_types->at(i).is_double2(), "Unexpected return verificationType");
3061 current_frame->push_stack(sig_verif_types->at(i), CHECK_VERIFY(this));
3062 }
3063 } else {
3064 // an <init> method may not have a void return type, if it's a static factory
3065 if (method_name == vmSymbols::object_initializer_name() &&
3066 opcode != Bytecodes::_invokespecial) {
3067 verify_error(ErrorContext::bad_code(bci),
3068 "Return type must be non-void in <init> static factory method");
3069 return;
3070 }
3071 }
3072 }
3073
3074 VerificationType ClassVerifier::get_newarray_type(
3075 u2 index, u2 bci, TRAPS) {
3076 const char* from_bt[] = {
3077 NULL, NULL, NULL, NULL, "[Z", "[C", "[F", "[D", "[B", "[S", "[I", "[J",
3078 };
3079 if (index < T_BOOLEAN || index > T_LONG) {
3080 verify_error(ErrorContext::bad_code(bci), "Illegal newarray instruction");
3081 return VerificationType::bogus_type();
3082 }
3083
3084 // from_bt[index] contains the array signature which has a length of 2
3085 Symbol* sig = create_temporary_symbol(
3086 from_bt[index], 2, CHECK_(VerificationType::bogus_type()));
3087 return VerificationType::reference_type(sig);
3088 }
3089
3090 void ClassVerifier::verify_anewarray(
|