114         }

   115         break;

   116       case JVM_CONSTANT_MethodHandle :

   117       case JVM_CONSTANT_MethodType :

   118         if (!EnableMethodHandles ||

   119             _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {

   120           classfile_parse_error(

   121             (!EnableInvokeDynamic ?

   122              "This JVM does not support constant tag %u in class file %s" :

   123              "Class file version does not support constant tag %u in class file %s"),

   124             tag, CHECK);

   125         }

   126         if (tag == JVM_CONSTANT_MethodHandle) {

   127           cfs->guarantee_more(4, CHECK);  // ref_kind, method_index, tag/access_flags

   128           u1 ref_kind = cfs->get_u1_fast();

   129           u2 method_index = cfs->get_u2_fast();

   130           cp->method_handle_index_at_put(index, ref_kind, method_index);

   131         } else if (tag == JVM_CONSTANT_MethodType) {

   132           cfs->guarantee_more(3, CHECK);  // signature_index, tag/access_flags

   133           u2 signature_index = cfs->get_u2_fast();

   134           cp->method_type_index_at_put(index, signature_index);

   135         } else {

   136           ShouldNotReachHere();

   359       case JVM_CONSTANT_MethodHandle :

   360         {

   361           int ref_index = cp->method_handle_index_at(index);

   362           check_property(

   363             valid_cp_range(ref_index, length) &&

   364                 EnableMethodHandles,

   365               "Invalid constant pool index %u in class file %s",

   366               ref_index, CHECK_(nullHandle));

   367           constantTag tag = cp->tag_at(ref_index);

   368           int ref_kind  = cp->method_handle_ref_kind_at(index);

   369           switch (ref_kind) {

   370           case JVM_REF_getField:

   371           case JVM_REF_getStatic:

   372           case JVM_REF_putField:

   373           case JVM_REF_putStatic:

   374             check_property(

   375               tag.is_field(),

   376               "Invalid constant pool index %u in class file %s (not a field)",

   377               ref_index, CHECK_(nullHandle));

   378             break;

   379           case JVM_REF_invokeVirtual:

   380           case JVM_REF_invokeStatic:

   381           case JVM_REF_invokeSpecial:

   382           case JVM_REF_newInvokeSpecial:

   383             check_property(

   384               tag.is_method(),

   385               "Invalid constant pool index %u in class file %s (not a method)",

   386               ref_index, CHECK_(nullHandle));

   387             break;

   388           case JVM_REF_invokeInterface:

   389             check_property(

   390               tag.is_interface_method(),

   391               "Invalid constant pool index %u in class file %s (not an interface method)",

   392               ref_index, CHECK_(nullHandle));

   393             break;

   394           default:

   395             classfile_parse_error(

   396               "Bad method handle kind at constant pool index %u in class file %s",

   397               index, CHECK_(nullHandle));

   398           }

   399           // Keep the ref_index unchanged.  It will be indirected at link-time.

   400         }

   401         break;

   402       case JVM_CONSTANT_MethodType :

   403         {

   404           int ref_index = cp->method_type_index_at(index);

   405           check_property(

   406             valid_cp_range(ref_index, length) &&

   407                 cp->tag_at(ref_index).is_utf8() &&

   408                 EnableMethodHandles,

   409               "Invalid constant pool index %u in class file %s",

   410               ref_index, CHECK_(nullHandle));

   411         }

   412         break;

   496       case JVM_CONSTANT_MethodHandle: {

   497         int ref_index = cp->method_handle_index_at(index);

   498         int ref_kind  = cp->method_handle_ref_kind_at(index);

   499         switch (ref_kind) {

   500         case JVM_REF_invokeVirtual:

   501         case JVM_REF_invokeStatic:

   502         case JVM_REF_invokeSpecial:

   503         case JVM_REF_newInvokeSpecial:

   504           {

   505             int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);

   506             int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);

   507             symbolHandle name(THREAD, cp->symbol_at(name_ref_index));

   508             if (ref_kind == JVM_REF_newInvokeSpecial) {

   509               if (name() != vmSymbols::object_initializer_name()) {

   510                 classfile_parse_error(

   511                   "Bad constructor name at constant pool index %u in class file %s",

   512                   name_ref_index, CHECK_(nullHandle));

   513               }

   514             } else {

   515               if (name() == vmSymbols::object_initializer_name()) {

   516                 classfile_parse_error(

   517                   "Bad method name at constant pool index %u in class file %s",

   518                   name_ref_index, CHECK_(nullHandle));

   519               }

   520             }

   521           }

   522           break;

   523           // Other ref_kinds are already fully checked in previous pass.

   524         }

   525         break;

   526       }

   527       case JVM_CONSTANT_MethodType: {

   528         symbolHandle no_name = vmSymbolHandles::type_name(); // place holder

   529         symbolHandle signature(THREAD, cp->method_type_signature_at(index));

   530         verify_legal_method_signature(no_name, signature, CHECK_(nullHandle));

   531         break;

   532       }