Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 1997, 2014, 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.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 #include "precompiled.hpp"

 #include "classfile/classFileParser.hpp"

 #include "classfile/classLoader.hpp"

 #include "classfile/classLoaderData.hpp"

 #include "classfile/classLoaderData.inline.hpp"

 #include "classfile/defaultMethods.hpp"

 #include "classfile/javaClasses.hpp"

 #include "classfile/symbolTable.hpp"

 #include "classfile/systemDictionary.hpp"

 #if INCLUDE_CDS

 #include "classfile/systemDictionaryShared.hpp"

 #endif

 #include "classfile/verificationType.hpp"

 #include "classfile/verifier.hpp"

 #include "classfile/vmSymbols.hpp"

 #include "memory/allocation.hpp"

 #include "memory/gcLocker.hpp"

 #include "memory/metadataFactory.hpp"

 #include "memory/oopFactory.hpp"

 #include "memory/referenceType.hpp"

 #include "memory/universe.inline.hpp"

 #include "oops/constantPool.hpp"

 #include "oops/fieldStreams.hpp"

 #include "oops/instanceKlass.hpp"

 #include "oops/instanceMirrorKlass.hpp"

 #include "oops/klass.inline.hpp"

 #include "oops/klassVtable.hpp"

 #include "oops/method.hpp"

 #include "oops/symbol.hpp"

 #include "prims/jvm.h"

 #include "prims/jvmtiExport.hpp"

 #include "prims/jvmtiThreadState.hpp"

 #include "runtime/javaCalls.hpp"

 #include "runtime/perfData.hpp"

 #include "runtime/reflection.hpp"

 #include "runtime/signature.hpp"

 #include "runtime/timer.hpp"

 #include "services/classLoadingService.hpp"

 #include "services/threadService.hpp"

 #include "utilities/array.hpp"

 #include "utilities/globalDefinitions.hpp"

 #include "utilities/ostream.hpp"

 // We generally try to create the oops directly when parsing, rather than

 // allocating temporary data structures and copying the bytes twice. A

 // temporary area is only needed when parsing utf8 entries in the constant

 // pool and when parsing line number tables.

 // We add assert in debug mode when class format is not checked.

 #define JAVA_CLASSFILE_MAGIC              0xCAFEBABE

 #define JAVA_MIN_SUPPORTED_VERSION        45

 #define JAVA_MAX_SUPPORTED_VERSION        52

 #define JAVA_MAX_SUPPORTED_MINOR_VERSION  0

 // Used for two backward compatibility reasons:

 // - to check for new additions to the class file format in JDK1.5

 // - to check for bug fixes in the format checker in JDK1.5

 #define JAVA_1_5_VERSION                  49

 // Used for backward compatibility reasons:

 // - to check for javac bug fixes that happened after 1.5

 // - also used as the max version when running in jdk6

 #define JAVA_6_VERSION                    50

 // Used for backward compatibility reasons:

 // - to check NameAndType_info signatures more aggressively

 #define JAVA_7_VERSION                    51

 // Extension method support.

 #define JAVA_8_VERSION                    52

 void ClassFileParser::parse_constant_pool_entries(int length, TRAPS) {

   // Use a local copy of ClassFileStream. It helps the C++ compiler to optimize

   // this function (_current can be allocated in a register, with scalar

   // replacement of aggregates). The _current pointer is copied back to

   // stream() when this function returns. DON'T call another method within

   // this method that uses stream().

   ClassFileStream* cfs0 = stream();

   ClassFileStream cfs1 = *cfs0;

   ClassFileStream* cfs = &cfs1;

 #ifdef ASSERT

   assert(cfs->allocated_on_stack(),"should be local");

   u1* old_current = cfs0->current();

 #endif

   Handle class_loader(THREAD, _loader_data->class_loader());

   // Used for batching symbol allocations.

   const char* names[SymbolTable::symbol_alloc_batch_size];

   int lengths[SymbolTable::symbol_alloc_batch_size];

   int indices[SymbolTable::symbol_alloc_batch_size];

   unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];

   int names_count = 0;

   // parsing  Index 0 is unused

   for (int index = 1; index < length; index++) {

     // Each of the following case guarantees one more byte in the stream

     // for the following tag or the access_flags following constant pool,

     // so we don't need bounds-check for reading tag.

     u1 tag = cfs->get_u1_fast();

     switch (tag) {

       case JVM_CONSTANT_Class :

         {

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

           u2 name_index = cfs->get_u2_fast();

           _cp->klass_index_at_put(index, name_index);

         }

         break;

       case JVM_CONSTANT_Fieldref :

         {

           cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags

           u2 class_index = cfs->get_u2_fast();

           u2 name_and_type_index = cfs->get_u2_fast();

           _cp->field_at_put(index, class_index, name_and_type_index);

         }

         break;

       case JVM_CONSTANT_Methodref :

         {

           cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags

           u2 class_index = cfs->get_u2_fast();

           u2 name_and_type_index = cfs->get_u2_fast();

           _cp->method_at_put(index, class_index, name_and_type_index);

         }

         break;

       case JVM_CONSTANT_InterfaceMethodref :

         {

           cfs->guarantee_more(5, CHECK);  // class_index, name_and_type_index, tag/access_flags

           u2 class_index = cfs->get_u2_fast();

           u2 name_and_type_index = cfs->get_u2_fast();

           _cp->interface_method_at_put(index, class_index, name_and_type_index);

         }

         break;

       case JVM_CONSTANT_String :

         {

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

           u2 string_index = cfs->get_u2_fast();

           _cp->string_index_at_put(index, string_index);

         }

         break;

       case JVM_CONSTANT_MethodHandle :

       case JVM_CONSTANT_MethodType :

         if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {

           classfile_parse_error(

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

             tag, CHECK);

         }

         if (!EnableInvokeDynamic) {

           classfile_parse_error(

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

             tag, CHECK);

         }

         if (tag == JVM_CONSTANT_MethodHandle) {

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

           u1 ref_kind = cfs->get_u1_fast();

           u2 method_index = cfs->get_u2_fast();

           _cp->method_handle_index_at_put(index, ref_kind, method_index);

         } else if (tag == JVM_CONSTANT_MethodType) {

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

           u2 signature_index = cfs->get_u2_fast();

           _cp->method_type_index_at_put(index, signature_index);

         } else {

           ShouldNotReachHere();

         }

         break;

       case JVM_CONSTANT_InvokeDynamic :

         {

           if (_major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {

             classfile_parse_error(

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

               tag, CHECK);

           }

           if (!EnableInvokeDynamic) {

             classfile_parse_error(

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

               tag, CHECK);

           }

           cfs->guarantee_more(5, CHECK);  // bsm_index, nt, tag/access_flags

           u2 bootstrap_specifier_index = cfs->get_u2_fast();

           u2 name_and_type_index = cfs->get_u2_fast();

           if (_max_bootstrap_specifier_index < (int) bootstrap_specifier_index)

             _max_bootstrap_specifier_index = (int) bootstrap_specifier_index;  // collect for later

           _cp->invoke_dynamic_at_put(index, bootstrap_specifier_index, name_and_type_index);

         }

         break;

       case JVM_CONSTANT_Integer :

         {

           cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags

           u4 bytes = cfs->get_u4_fast();

           _cp->int_at_put(index, (jint) bytes);

         }

         break;

       case JVM_CONSTANT_Float :

         {

           cfs->guarantee_more(5, CHECK);  // bytes, tag/access_flags

           u4 bytes = cfs->get_u4_fast();

           _cp->float_at_put(index, *(jfloat*)&bytes);

         }

         break;

       case JVM_CONSTANT_Long :

         // A mangled type might cause you to overrun allocated memory

         guarantee_property(index+1 < length,

                            "Invalid constant pool entry %u in class file %s",

                            index, CHECK);

         {

           cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags

           u8 bytes = cfs->get_u8_fast();

           _cp->long_at_put(index, bytes);

         }

         index++;   // Skip entry following eigth-byte constant, see JVM book p. 98

         break;

       case JVM_CONSTANT_Double :

         // A mangled type might cause you to overrun allocated memory

         guarantee_property(index+1 < length,

                            "Invalid constant pool entry %u in class file %s",

                            index, CHECK);

         {

           cfs->guarantee_more(9, CHECK);  // bytes, tag/access_flags

           u8 bytes = cfs->get_u8_fast();

           _cp->double_at_put(index, *(jdouble*)&bytes);

         }

         index++;   // Skip entry following eigth-byte constant, see JVM book p. 98

         break;

       case JVM_CONSTANT_NameAndType :

         {

           cfs->guarantee_more(5, CHECK);  // name_index, signature_index, tag/access_flags

           u2 name_index = cfs->get_u2_fast();

           u2 signature_index = cfs->get_u2_fast();

           _cp->name_and_type_at_put(index, name_index, signature_index);

         }

         break;

       case JVM_CONSTANT_Utf8 :

         {

           cfs->guarantee_more(2, CHECK);  // utf8_length

           u2  utf8_length = cfs->get_u2_fast();

           u1* utf8_buffer = cfs->get_u1_buffer();

           assert(utf8_buffer != NULL, "null utf8 buffer");

           // Got utf8 string, guarantee utf8_length+1 bytes, set stream position forward.

           cfs->guarantee_more(utf8_length+1, CHECK);  // utf8 string, tag/access_flags

           cfs->skip_u1_fast(utf8_length);

           // Before storing the symbol, make sure it's legal

           if (_need_verify) {

             verify_legal_utf8((unsigned char*)utf8_buffer, utf8_length, CHECK);

           }

           if (EnableInvokeDynamic && has_cp_patch_at(index)) {

             Handle patch = clear_cp_patch_at(index);

             guarantee_property(java_lang_String::is_instance(patch()),

                                "Illegal utf8 patch at %d in class file %s",

                                index, CHECK);

             char* str = java_lang_String::as_utf8_string(patch());

             // (could use java_lang_String::as_symbol instead, but might as well batch them)

             utf8_buffer = (u1*) str;

             utf8_length = (int) strlen(str);

           }

           unsigned int hash;

           Symbol* result = SymbolTable::lookup_only((char*)utf8_buffer, utf8_length, hash);

           if (result == NULL) {

             names[names_count] = (char*)utf8_buffer;

             lengths[names_count] = utf8_length;

             indices[names_count] = index;

             hashValues[names_count++] = hash;

             if (names_count == SymbolTable::symbol_alloc_batch_size) {

               SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);

               names_count = 0;

             }

           } else {

             _cp->symbol_at_put(index, result);

           }

         }

         break;

       default:

         classfile_parse_error(

           "Unknown constant tag %u in class file %s", tag, CHECK);

         break;

     }

   }

   // Allocate the remaining symbols

   if (names_count > 0) {

     SymbolTable::new_symbols(_loader_data, _cp, names_count, names, lengths, indices, hashValues, CHECK);

   }

   // Copy _current pointer of local copy back to stream().

 #ifdef ASSERT

   assert(cfs0->current() == old_current, "non-exclusive use of stream()");

 #endif

   cfs0->set_current(cfs1.current());

 }

 bool inline valid_cp_range(int index, int length) { return (index > 0 && index < length); }

 inline Symbol* check_symbol_at(constantPoolHandle cp, int index) {

   if (valid_cp_range(index, cp->length()) && cp->tag_at(index).is_utf8())

     return cp->symbol_at(index);

   else

     return NULL;

 }

 constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {

   ClassFileStream* cfs = stream();

   constantPoolHandle nullHandle;

   cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag

   u2 length = cfs->get_u2_fast();

   guarantee_property(

     length >= 1, "Illegal constant pool size %u in class file %s",

     length, CHECK_(nullHandle));

   ConstantPool* constant_pool = ConstantPool::allocate(_loader_data, length,

                                                         CHECK_(nullHandle));

   _cp = constant_pool; // save in case of errors

   constantPoolHandle cp (THREAD, constant_pool);

   // parsing constant pool entries

   parse_constant_pool_entries(length, CHECK_(nullHandle));

   int index = 1;  // declared outside of loops for portability

   // first verification pass - validate cross references and fixup class and string constants

   for (index = 1; index < length; index++) {          // Index 0 is unused

     jbyte tag = cp->tag_at(index).value();

     switch (tag) {

       case JVM_CONSTANT_Class :

         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present

         break;

       case JVM_CONSTANT_Fieldref :

         // fall through

       case JVM_CONSTANT_Methodref :

         // fall through

       case JVM_CONSTANT_InterfaceMethodref : {

         if (!_need_verify) break;

         int klass_ref_index = cp->klass_ref_index_at(index);

         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);

         check_property(valid_klass_reference_at(klass_ref_index),

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

                        klass_ref_index,

                        CHECK_(nullHandle));

         check_property(valid_cp_range(name_and_type_ref_index, length) &&

                        cp->tag_at(name_and_type_ref_index).is_name_and_type(),

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

                        name_and_type_ref_index,

                        CHECK_(nullHandle));

         break;

       }

       case JVM_CONSTANT_String :

         ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present

         break;

       case JVM_CONSTANT_Integer :

         break;

       case JVM_CONSTANT_Float :

         break;

       case JVM_CONSTANT_Long :

       case JVM_CONSTANT_Double :

         index++;

         check_property(

           (index < length && cp->tag_at(index).is_invalid()),

           "Improper constant pool long/double index %u in class file %s",

           index, CHECK_(nullHandle));

         break;

       case JVM_CONSTANT_NameAndType : {

         if (!_need_verify) break;

         int name_ref_index = cp->name_ref_index_at(index);

         int signature_ref_index = cp->signature_ref_index_at(index);

         check_property(valid_symbol_at(name_ref_index),

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

                  name_ref_index, CHECK_(nullHandle));

         check_property(valid_symbol_at(signature_ref_index),

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

                  signature_ref_index, CHECK_(nullHandle));

         break;

       }

       case JVM_CONSTANT_Utf8 :

         break;

       case JVM_CONSTANT_UnresolvedClass :         // fall-through

       case JVM_CONSTANT_UnresolvedClassInError:

         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present

         break;

       case JVM_CONSTANT_ClassIndex :

         {

           int class_index = cp->klass_index_at(index);

           check_property(valid_symbol_at(class_index),

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

                  class_index, CHECK_(nullHandle));

           cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));

         }

         break;

       case JVM_CONSTANT_StringIndex :

         {

           int string_index = cp->string_index_at(index);

           check_property(valid_symbol_at(string_index),

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

                  string_index, CHECK_(nullHandle));

           Symbol* sym = cp->symbol_at(string_index);

           cp->unresolved_string_at_put(index, sym);

         }

         break;

       case JVM_CONSTANT_MethodHandle :

         {

           int ref_index = cp->method_handle_index_at(index);

           check_property(

             valid_cp_range(ref_index, length) &&

                 EnableInvokeDynamic,

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

               ref_index, CHECK_(nullHandle));

           constantTag tag = cp->tag_at(ref_index);

           int ref_kind  = cp->method_handle_ref_kind_at(index);

           switch (ref_kind) {

           case JVM_REF_getField:

           case JVM_REF_getStatic:

           case JVM_REF_putField:

           case JVM_REF_putStatic:

             check_property(

               tag.is_field(),

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

               ref_index, CHECK_(nullHandle));

             break;

           case JVM_REF_invokeVirtual:

           case JVM_REF_newInvokeSpecial:

             check_property(

               tag.is_method(),

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

               ref_index, CHECK_(nullHandle));

             break;

           case JVM_REF_invokeStatic:

           case JVM_REF_invokeSpecial:

             check_property(tag.is_method() ||

                            ((_major_version >= JAVA_8_VERSION) && tag.is_interface_method()),

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

                ref_index, CHECK_(nullHandle));

              break;

           case JVM_REF_invokeInterface:

             check_property(

               tag.is_interface_method(),

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

               ref_index, CHECK_(nullHandle));

             break;

           default:

             classfile_parse_error(

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

               index, CHECK_(nullHandle));

           }

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

         }

         break;

       case JVM_CONSTANT_MethodType :

         {

           int ref_index = cp->method_type_index_at(index);

           check_property(valid_symbol_at(ref_index) && EnableInvokeDynamic,

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

                  ref_index, CHECK_(nullHandle));

         }

         break;

       case JVM_CONSTANT_InvokeDynamic :

         {

           int name_and_type_ref_index = cp->invoke_dynamic_name_and_type_ref_index_at(index);

           check_property(valid_cp_range(name_and_type_ref_index, length) &&

                          cp->tag_at(name_and_type_ref_index).is_name_and_type(),

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

                          name_and_type_ref_index,

                          CHECK_(nullHandle));

           // bootstrap specifier index must be checked later, when BootstrapMethods attr is available

           break;

         }

       default:

         fatal(err_msg("bad constant pool tag value %u",

                       cp->tag_at(index).value()));

         ShouldNotReachHere();

         break;

     } // end of switch

   } // end of for

   if (_cp_patches != NULL) {

     // need to treat this_class specially...

     assert(EnableInvokeDynamic, "");

     int this_class_index;

     {

       cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len

       u1* mark = cfs->current();

       u2 flags         = cfs->get_u2_fast();

       this_class_index = cfs->get_u2_fast();

       cfs->set_current(mark);  // revert to mark

     }

     for (index = 1; index < length; index++) {          // Index 0 is unused

       if (has_cp_patch_at(index)) {

         guarantee_property(index != this_class_index,

                            "Illegal constant pool patch to self at %d in class file %s",

                            index, CHECK_(nullHandle));

         patch_constant_pool(cp, index, cp_patch_at(index), CHECK_(nullHandle));

       }

     }

   }

   if (!_need_verify) {

     return cp;

   }

   // second verification pass - checks the strings are of the right format.

   // but not yet to the other entries

   for (index = 1; index < length; index++) {

     jbyte tag = cp->tag_at(index).value();

     switch (tag) {

       case JVM_CONSTANT_UnresolvedClass: {

         Symbol*  class_name = cp->unresolved_klass_at(index);

         // check the name, even if _cp_patches will overwrite it

         verify_legal_class_name(class_name, CHECK_(nullHandle));

         break;

       }

       case JVM_CONSTANT_NameAndType: {

         if (_need_verify && _major_version >= JAVA_7_VERSION) {

           int sig_index = cp->signature_ref_index_at(index);

           int name_index = cp->name_ref_index_at(index);

           Symbol*  name = cp->symbol_at(name_index);

           Symbol*  sig = cp->symbol_at(sig_index);

           if (sig->byte_at(0) == JVM_SIGNATURE_FUNC) {

             verify_legal_method_signature(name, sig, CHECK_(nullHandle));

           } else {

             verify_legal_field_signature(name, sig, CHECK_(nullHandle));

           }

         }

         break;

       }

       case JVM_CONSTANT_InvokeDynamic:

       case JVM_CONSTANT_Fieldref:

       case JVM_CONSTANT_Methodref:

       case JVM_CONSTANT_InterfaceMethodref: {

         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);

         // already verified to be utf8

         int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);

         // already verified to be utf8

         int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);

         Symbol*  name = cp->symbol_at(name_ref_index);

         Symbol*  signature = cp->symbol_at(signature_ref_index);

         if (tag == JVM_CONSTANT_Fieldref) {

           verify_legal_field_name(name, CHECK_(nullHandle));

           if (_need_verify && _major_version >= JAVA_7_VERSION) {

             // Signature is verified above, when iterating NameAndType_info.

             // Need only to be sure it's the right type.

             if (signature->byte_at(0) == JVM_SIGNATURE_FUNC) {

               throwIllegalSignature(

                   "Field", name, signature, CHECK_(nullHandle));

             }

           } else {

             verify_legal_field_signature(name, signature, CHECK_(nullHandle));

           }

         } else {

           verify_legal_method_name(name, CHECK_(nullHandle));

           if (_need_verify && _major_version >= JAVA_7_VERSION) {

             // Signature is verified above, when iterating NameAndType_info.

             // Need only to be sure it's the right type.

             if (signature->byte_at(0) != JVM_SIGNATURE_FUNC) {

               throwIllegalSignature(

                   "Method", name, signature, CHECK_(nullHandle));

             }

           } else {

             verify_legal_method_signature(name, signature, CHECK_(nullHandle));

           }

           if (tag == JVM_CONSTANT_Methodref) {

             // 4509014: If a class method name begins with '<', it must be "<init>".

             assert(name != NULL, "method name in constant pool is null");

             unsigned int name_len = name->utf8_length();

             assert(name_len > 0, "bad method name");  // already verified as legal name

             if (name->byte_at(0) == '<') {

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

                 classfile_parse_error(

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

                   name_ref_index, CHECK_(nullHandle));

               }

             }

           }

         }

         break;

       }

       case JVM_CONSTANT_MethodHandle: {

         int ref_index = cp->method_handle_index_at(index);

         int ref_kind  = cp->method_handle_ref_kind_at(index);

         switch (ref_kind) {

         case JVM_REF_invokeVirtual:

         case JVM_REF_invokeStatic:

         case JVM_REF_invokeSpecial:

         case JVM_REF_newInvokeSpecial:

           {

             int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);

             int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);

             Symbol*  name = cp->symbol_at(name_ref_index);

             if (ref_kind == JVM_REF_newInvokeSpecial) {

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

                 classfile_parse_error(

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

                   name_ref_index, CHECK_(nullHandle));

               }

             } else {

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

                 classfile_parse_error(

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

                   name_ref_index, CHECK_(nullHandle));

               }

             }

           }

           break;

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

         }

         break;

       }

       case JVM_CONSTANT_MethodType: {

         Symbol* no_name = vmSymbols::type_name(); // place holder

         Symbol*  signature = cp->method_type_signature_at(index);

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

         break;

       }

       case JVM_CONSTANT_Utf8: {

         assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");

       }

     }  // end of switch

   }  // end of for

   return cp;

 }

 void ClassFileParser::patch_constant_pool(constantPoolHandle cp, int index, Handle patch, TRAPS) {

   assert(EnableInvokeDynamic, "");

   BasicType patch_type = T_VOID;

   switch (cp->tag_at(index).value()) {

   case JVM_CONSTANT_UnresolvedClass :

     // Patching a class means pre-resolving it.

     // The name in the constant pool is ignored.

     if (java_lang_Class::is_instance(patch())) {

       guarantee_property(!java_lang_Class::is_primitive(patch()),

                          "Illegal class patch at %d in class file %s",

                          index, CHECK);

       cp->klass_at_put(index, java_lang_Class::as_Klass(patch()));

     } else {

       guarantee_property(java_lang_String::is_instance(patch()),

                          "Illegal class patch at %d in class file %s",

                          index, CHECK);

       Symbol* name = java_lang_String::as_symbol(patch(), CHECK);

       cp->unresolved_klass_at_put(index, name);

     }

     break;

   case JVM_CONSTANT_String :

     // skip this patch and don't clear it.  Needs the oop array for resolved

     // references to be created first.

     return;

   case JVM_CONSTANT_Integer : patch_type = T_INT;    goto patch_prim;

   case JVM_CONSTANT_Float :   patch_type = T_FLOAT;  goto patch_prim;

   case JVM_CONSTANT_Long :    patch_type = T_LONG;   goto patch_prim;

   case JVM_CONSTANT_Double :  patch_type = T_DOUBLE; goto patch_prim;

   patch_prim:

     {

       jvalue value;

       BasicType value_type = java_lang_boxing_object::get_value(patch(), &value);

       guarantee_property(value_type == patch_type,

                          "Illegal primitive patch at %d in class file %s",

                          index, CHECK);

       switch (value_type) {

       case T_INT:    cp->int_at_put(index,   value.i); break;

       case T_FLOAT:  cp->float_at_put(index, value.f); break;

       case T_LONG:   cp->long_at_put(index,  value.j); break;

       case T_DOUBLE: cp->double_at_put(index, value.d); break;

       default:       assert(false, "");

       }

     }

     break;

   default:

     // %%% TODO: put method handles into CONSTANT_InterfaceMethodref, etc.

     guarantee_property(!has_cp_patch_at(index),

                        "Illegal unexpected patch at %d in class file %s",

                        index, CHECK);

     return;

   }

   // On fall-through, mark the patch as used.

   clear_cp_patch_at(index);

 }

 class NameSigHash: public ResourceObj {

  public:

   Symbol*       _name;       // name

   Symbol*       _sig;        // signature

   NameSigHash*  _next;       // Next entry in hash table

 };

 #define HASH_ROW_SIZE 256

 unsigned int hash(Symbol* name, Symbol* sig) {

   unsigned int raw_hash = 0;

   raw_hash += ((unsigned int)(uintptr_t)name) >> (LogHeapWordSize + 2);

   raw_hash += ((unsigned int)(uintptr_t)sig) >> LogHeapWordSize;

   return (raw_hash + (unsigned int)(uintptr_t)name) % HASH_ROW_SIZE;

 }

 void initialize_hashtable(NameSigHash** table) {

   memset((void*)table, 0, sizeof(NameSigHash*) * HASH_ROW_SIZE);

 }

 // Return false if the name/sig combination is found in table.

 // Return true if no duplicate is found. And name/sig is added as a new entry in table.

 // The old format checker uses heap sort to find duplicates.

 // NOTE: caller should guarantee that GC doesn't happen during the life cycle

 // of table since we don't expect Symbol*'s to move.

 bool put_after_lookup(Symbol* name, Symbol* sig, NameSigHash** table) {

   assert(name != NULL, "name in constant pool is NULL");

   // First lookup for duplicates

   int index = hash(name, sig);

   NameSigHash* entry = table[index];

   while (entry != NULL) {

     if (entry->_name == name && entry->_sig == sig) {

       return false;

     }

     entry = entry->_next;

   }

   // No duplicate is found, allocate a new entry and fill it.

   entry = new NameSigHash();

   entry->_name = name;

   entry->_sig = sig;

   // Insert into hash table

   entry->_next = table[index];

   table[index] = entry;

   return true;

 }

 Array<Klass*>* ClassFileParser::parse_interfaces(int length,

                                                  Handle protection_domain,

                                                  Symbol* class_name,

                                                  bool* has_default_methods,

                                                  TRAPS) {

   if (length == 0) {

     _local_interfaces = Universe::the_empty_klass_array();

   } else {

     ClassFileStream* cfs = stream();

     assert(length > 0, "only called for length>0");

     _local_interfaces = MetadataFactory::new_array<Klass*>(_loader_data, length, NULL, CHECK_NULL);

     int index;

     for (index = 0; index < length; index++) {

       u2 interface_index = cfs->get_u2(CHECK_NULL);

       KlassHandle interf;

       check_property(

         valid_klass_reference_at(interface_index),

         "Interface name has bad constant pool index %u in class file %s",

         interface_index, CHECK_NULL);

       if (_cp->tag_at(interface_index).is_klass()) {

         interf = KlassHandle(THREAD, _cp->resolved_klass_at(interface_index));

       } else {

         Symbol*  unresolved_klass  = _cp->klass_name_at(interface_index);

         // Don't need to check legal name because it's checked when parsing constant pool.

         // But need to make sure it's not an array type.

         guarantee_property(unresolved_klass->byte_at(0) != JVM_SIGNATURE_ARRAY,

                            "Bad interface name in class file %s", CHECK_NULL);

         Handle class_loader(THREAD, _loader_data->class_loader());

         // Call resolve_super so classcircularity is checked

         Klass* k = SystemDictionary::resolve_super_or_fail(class_name,

                       unresolved_klass, class_loader, protection_domain,

                       false, CHECK_NULL);

         interf = KlassHandle(THREAD, k);

       }

       if (!interf()->is_interface()) {

         THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", NULL);

       }

       if (InstanceKlass::cast(interf())->has_default_methods()) {

         *has_default_methods = true;

       }

       _local_interfaces->at_put(index, interf());

     }

     if (!_need_verify || length <= 1) {

       return _local_interfaces;

     }

     // Check if there's any duplicates in interfaces

     ResourceMark rm(THREAD);

     NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(

       THREAD, NameSigHash*, HASH_ROW_SIZE);

     initialize_hashtable(interface_names);

     bool dup = false;

     {

       debug_only(No_Safepoint_Verifier nsv;)

       for (index = 0; index < length; index++) {

         Klass* k = _local_interfaces->at(index);

         Symbol* name = InstanceKlass::cast(k)->name();

         // If no duplicates, add (name, NULL) in hashtable interface_names.

         if (!put_after_lookup(name, NULL, interface_names)) {

           dup = true;

           break;

         }

       }

     }

     if (dup) {

       classfile_parse_error("Duplicate interface name in class file %s", CHECK_NULL);

     }

   }

   return _local_interfaces;

 }

 void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, TRAPS) {

   // Make sure the constant pool entry is of a type appropriate to this field

   guarantee_property(

     (constantvalue_index > 0 &&

       constantvalue_index < _cp->length()),

     "Bad initial value index %u in ConstantValue attribute in class file %s",

     constantvalue_index, CHECK);

   constantTag value_type = _cp->tag_at(constantvalue_index);

   switch ( _cp->basic_type_for_signature_at(signature_index) ) {

     case T_LONG:

       guarantee_property(value_type.is_long(), "Inconsistent constant value type in class file %s", CHECK);

       break;

     case T_FLOAT:

       guarantee_property(value_type.is_float(), "Inconsistent constant value type in class file %s", CHECK);

       break;

     case T_DOUBLE:

       guarantee_property(value_type.is_double(), "Inconsistent constant value type in class file %s", CHECK);

       break;

     case T_BYTE: case T_CHAR: case T_SHORT: case T_BOOLEAN: case T_INT:

       guarantee_property(value_type.is_int(), "Inconsistent constant value type in class file %s", CHECK);

       break;

     case T_OBJECT:

       guarantee_property((_cp->symbol_at(signature_index)->equals("Ljava/lang/String;")

                          && value_type.is_string()),

                          "Bad string initial value in class file %s", CHECK);

       break;

     default:

       classfile_parse_error(

         "Unable to set initial value %u in class file %s",

         constantvalue_index, CHECK);

   }

 }

 // Parse attributes for a field.

 void ClassFileParser::parse_field_attributes(u2 attributes_count,

                                              bool is_static, u2 signature_index,

                                              u2* constantvalue_index_addr,

                                              bool* is_synthetic_addr,

                                              u2* generic_signature_index_addr,

                                              ClassFileParser::FieldAnnotationCollector* parsed_annotations,

                                              TRAPS) {

   ClassFileStream* cfs = stream();

   assert(attributes_count > 0, "length should be greater than 0");

   u2 constantvalue_index = 0;

   u2 generic_signature_index = 0;

   bool is_synthetic = false;

   u1* runtime_visible_annotations = NULL;

   int runtime_visible_annotations_length = 0;

   u1* runtime_invisible_annotations = NULL;

   int runtime_invisible_annotations_length = 0;

   u1* runtime_visible_type_annotations = NULL;

   int runtime_visible_type_annotations_length = 0;

   u1* runtime_invisible_type_annotations = NULL;

   int runtime_invisible_type_annotations_length = 0;

   bool runtime_invisible_type_annotations_exists = false;

   while (attributes_count--) {

     cfs->guarantee_more(6, CHECK);  // attribute_name_index, attribute_length

     u2 attribute_name_index = cfs->get_u2_fast();

     u4 attribute_length = cfs->get_u4_fast();

     check_property(valid_symbol_at(attribute_name_index),

                    "Invalid field attribute index %u in class file %s",

                    attribute_name_index,

                    CHECK);

     Symbol* attribute_name = _cp->symbol_at(attribute_name_index);

     if (is_static && attribute_name == vmSymbols::tag_constant_value()) {

       // ignore if non-static

       if (constantvalue_index != 0) {

         classfile_parse_error("Duplicate ConstantValue attribute in class file %s", CHECK);

       }

       check_property(

         attribute_length == 2,

         "Invalid ConstantValue field attribute length %u in class file %s",

         attribute_length, CHECK);

       constantvalue_index = cfs->get_u2(CHECK);

       if (_need_verify) {

         verify_constantvalue(constantvalue_index, signature_index, CHECK);

       }

     } else if (attribute_name == vmSymbols::tag_synthetic()) {

       if (attribute_length != 0) {

         classfile_parse_error(

           "Invalid Synthetic field attribute length %u in class file %s",

           attribute_length, CHECK);

       }

       is_synthetic = true;

     } else if (attribute_name == vmSymbols::tag_deprecated()) { // 4276120

       if (attribute_length != 0) {

         classfile_parse_error(

           "Invalid Deprecated field attribute length %u in class file %s",

           attribute_length, CHECK);

       }

     } else if (_major_version >= JAVA_1_5_VERSION) {

       if (attribute_name == vmSymbols::tag_signature()) {

         if (attribute_length != 2) {

           classfile_parse_error(

             "Wrong size %u for field's Signature attribute in class file %s",

             attribute_length, CHECK);

         }

         generic_signature_index = parse_generic_signature_attribute(CHECK);

       } else if (attribute_name == vmSymbols::tag_runtime_visible_annotations()) {

         runtime_visible_annotations_length = attribute_length;

         runtime_visible_annotations = cfs->get_u1_buffer();

         assert(runtime_visible_annotations != NULL, "null visible annotations");

         parse_annotations(runtime_visible_annotations,

                           runtime_visible_annotations_length,

                           parsed_annotations,

                           CHECK);

         cfs->skip_u1(runtime_visible_annotations_length, CHECK);

       } else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {

         runtime_invisible_annotations_length = attribute_length;

         runtime_invisible_annotations = cfs->get_u1_buffer();

         assert(runtime_invisible_annotations != NULL, "null invisible annotations");

         cfs->skip_u1(runtime_invisible_annotations_length, CHECK);

       } else if (attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) {

         if (runtime_visible_type_annotations != NULL) {

           classfile_parse_error(

             "Multiple RuntimeVisibleTypeAnnotations attributes for field in class file %s", CHECK);

         }

         runtime_visible_type_annotations_length = attribute_length;

         runtime_visible_type_annotations = cfs->get_u1_buffer();

         assert(runtime_visible_type_annotations != NULL, "null visible type annotations");

         cfs->skip_u1(runtime_visible_type_annotations_length, CHECK);

       } else if (attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {

         if (runtime_invisible_type_annotations_exists) {

           classfile_parse_error(

             "Multiple RuntimeInvisibleTypeAnnotations attributes for field in class file %s", CHECK);

         } else {

           runtime_invisible_type_annotations_exists = true;

         }

         if (PreserveAllAnnotations) {

           runtime_invisible_type_annotations_length = attribute_length;

           runtime_invisible_type_annotations = cfs->get_u1_buffer();

           assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");

         }

         cfs->skip_u1(attribute_length, CHECK);

       } else {

         cfs->skip_u1(attribute_length, CHECK);  // Skip unknown attributes

       }

     } else {

       cfs->skip_u1(attribute_length, CHECK);  // Skip unknown attributes

     }

   }

   *constantvalue_index_addr = constantvalue_index;

   *is_synthetic_addr = is_synthetic;

   *generic_signature_index_addr = generic_signature_index;

   AnnotationArray* a = assemble_annotations(runtime_visible_annotations,

                                             runtime_visible_annotations_length,

                                             runtime_invisible_annotations,

                                             runtime_invisible_annotations_length,

                                             CHECK);

   parsed_annotations->set_field_annotations(a);

   a = assemble_annotations(runtime_visible_type_annotations,

                            runtime_visible_type_annotations_length,

                            runtime_invisible_type_annotations,

                            runtime_invisible_type_annotations_length,

                            CHECK);

   parsed_annotations->set_field_type_annotations(a);

   return;

 }

 // Field allocation types. Used for computing field offsets.

 enum FieldAllocationType {

   STATIC_OOP,           // Oops

   STATIC_BYTE,          // Boolean, Byte, char

   STATIC_SHORT,         // shorts

   STATIC_WORD,          // ints

   STATIC_DOUBLE,        // aligned long or double

   NONSTATIC_OOP,

   NONSTATIC_BYTE,

   NONSTATIC_SHORT,

   NONSTATIC_WORD,

   NONSTATIC_DOUBLE,

   MAX_FIELD_ALLOCATION_TYPE,

   BAD_ALLOCATION_TYPE = -1

 };

 static FieldAllocationType _basic_type_to_atype[2 * (T_CONFLICT + 1)] = {

   BAD_ALLOCATION_TYPE, // 0

   BAD_ALLOCATION_TYPE, // 1

   BAD_ALLOCATION_TYPE, // 2

   BAD_ALLOCATION_TYPE, // 3

   NONSTATIC_BYTE ,     // T_BOOLEAN     =  4,

   NONSTATIC_SHORT,     // T_CHAR        =  5,

   NONSTATIC_WORD,      // T_FLOAT       =  6,

   NONSTATIC_DOUBLE,    // T_DOUBLE      =  7,

   NONSTATIC_BYTE,      // T_BYTE        =  8,

   NONSTATIC_SHORT,     // T_SHORT       =  9,

   NONSTATIC_WORD,      // T_INT         = 10,

   NONSTATIC_DOUBLE,    // T_LONG        = 11,

   NONSTATIC_OOP,       // T_OBJECT      = 12,

   NONSTATIC_OOP,       // T_ARRAY       = 13,

   BAD_ALLOCATION_TYPE, // T_VOID        = 14,

   BAD_ALLOCATION_TYPE, // T_ADDRESS     = 15,

   BAD_ALLOCATION_TYPE, // T_NARROWOOP   = 16,

   BAD_ALLOCATION_TYPE, // T_METADATA    = 17,

   BAD_ALLOCATION_TYPE, // T_NARROWKLASS = 18,

   BAD_ALLOCATION_TYPE, // T_CONFLICT    = 19,

   BAD_ALLOCATION_TYPE, // 0

   BAD_ALLOCATION_TYPE, // 1

   BAD_ALLOCATION_TYPE, // 2

   BAD_ALLOCATION_TYPE, // 3

   STATIC_BYTE ,        // T_BOOLEAN     =  4,

   STATIC_SHORT,        // T_CHAR        =  5,

   STATIC_WORD,         // T_FLOAT       =  6,

   STATIC_DOUBLE,       // T_DOUBLE      =  7,

   STATIC_BYTE,         // T_BYTE        =  8,

   STATIC_SHORT,        // T_SHORT       =  9,

   STATIC_WORD,         // T_INT         = 10,

   STATIC_DOUBLE,       // T_LONG        = 11,

   STATIC_OOP,          // T_OBJECT      = 12,

   STATIC_OOP,          // T_ARRAY       = 13,

   BAD_ALLOCATION_TYPE, // T_VOID        = 14,

   BAD_ALLOCATION_TYPE, // T_ADDRESS     = 15,

   BAD_ALLOCATION_TYPE, // T_NARROWOOP   = 16,

   BAD_ALLOCATION_TYPE, // T_METADATA    = 17,

   BAD_ALLOCATION_TYPE, // T_NARROWKLASS = 18,

   BAD_ALLOCATION_TYPE, // T_CONFLICT    = 19,

 };

 static FieldAllocationType basic_type_to_atype(bool is_static, BasicType type) {

   assert(type >= T_BOOLEAN && type < T_VOID, "only allowable values");

   FieldAllocationType result = _basic_type_to_atype[type + (is_static ? (T_CONFLICT + 1) : 0)];

   assert(result != BAD_ALLOCATION_TYPE, "bad type");

   return result;

 }

 class FieldAllocationCount: public ResourceObj {

  public:

   u2 count[MAX_FIELD_ALLOCATION_TYPE];

   FieldAllocationCount() {

     for (int i = 0; i < MAX_FIELD_ALLOCATION_TYPE; i++) {

       count[i] = 0;

     }

   }

   FieldAllocationType update(bool is_static, BasicType type) {

     FieldAllocationType atype = basic_type_to_atype(is_static, type);

     // Make sure there is no overflow with injected fields.

     assert(count[atype] < 0xFFFF, "More than 65535 fields");

     count[atype]++;

     return atype;

   }

 };

 Array<u2>* ClassFileParser::parse_fields(Symbol* class_name,

                                          bool is_interface,

                                          FieldAllocationCount *fac,

                                          u2* java_fields_count_ptr, TRAPS) {

   ClassFileStream* cfs = stream();

   cfs->guarantee_more(2, CHECK_NULL);  // length

   u2 length = cfs->get_u2_fast();

   *java_fields_count_ptr = length;

   int num_injected = 0;

   InjectedField* injected = JavaClasses::get_injected(class_name, &num_injected);

   int total_fields = length + num_injected;

   // The field array starts with tuples of shorts

   // [access, name index, sig index, initial value index, byte offset].

   // A generic signature slot only exists for field with generic

   // signature attribute. And the access flag is set with

   // JVM_ACC_FIELD_HAS_GENERIC_SIGNATURE for that field. The generic

   // signature slots are at the end of the field array and after all

   // other fields data.

   //

   //   f1: [access, name index, sig index, initial value index, low_offset, high_offset]

   //   f2: [access, name index, sig index, initial value index, low_offset, high_offset]

   //       ...

   //   fn: [access, name index, sig index, initial value index, low_offset, high_offset]

   //       [generic signature index]

   //       [generic signature index]

   //       ...

   //

   // Allocate a temporary resource array for field data. For each field,

   // a slot is reserved in the temporary array for the generic signature

   // index. After parsing all fields, the data are copied to a permanent

   // array and any unused slots will be discarded.

   ResourceMark rm(THREAD);

   u2* fa = NEW_RESOURCE_ARRAY_IN_THREAD(

              THREAD, u2, total_fields * (FieldInfo::field_slots + 1));

   // The generic signature slots start after all other fields' data.

   int generic_signature_slot = total_fields * FieldInfo::field_slots;

   int num_generic_signature = 0;

   for (int n = 0; n < length; n++) {

     cfs->guarantee_more(8, CHECK_NULL);  // access_flags, name_index, descriptor_index, attributes_count

     AccessFlags access_flags;

     jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_FIELD_MODIFIERS;

     verify_legal_field_modifiers(flags, is_interface, CHECK_NULL);

     access_flags.set_flags(flags);

     u2 name_index = cfs->get_u2_fast();

     int cp_size = _cp->length();

     check_property(valid_symbol_at(name_index),

       "Invalid constant pool index %u for field name in class file %s",

       name_index,

       CHECK_NULL);

     Symbol*  name = _cp->symbol_at(name_index);

     verify_legal_field_name(name, CHECK_NULL);

     u2 signature_index = cfs->get_u2_fast();

     check_property(valid_symbol_at(signature_index),

       "Invalid constant pool index %u for field signature in class file %s",

       signature_index, CHECK_NULL);

     Symbol*  sig = _cp->symbol_at(signature_index);

     verify_legal_field_signature(name, sig, CHECK_NULL);

     u2 constantvalue_index = 0;

     bool is_synthetic = false;

     u2 generic_signature_index = 0;

     bool is_static = access_flags.is_static();

     FieldAnnotationCollector parsed_annotations(_loader_data);

     u2 attributes_count = cfs->get_u2_fast();

     if (attributes_count > 0) {

       parse_field_attributes(attributes_count, is_static, signature_index,

                              &constantvalue_index, &is_synthetic,

                              &generic_signature_index, &parsed_annotations,

                              CHECK_NULL);

       if (parsed_annotations.field_annotations() != NULL) {

         if (_fields_annotations == NULL) {

           _fields_annotations = MetadataFactory::new_array<AnnotationArray*>(

                                              _loader_data, length, NULL,

                                              CHECK_NULL);

         }

         _fields_annotations->at_put(n, parsed_annotations.field_annotations());

         parsed_annotations.set_field_annotations(NULL);

       }

       if (parsed_annotations.field_type_annotations() != NULL) {

         if (_fields_type_annotations == NULL) {

           _fields_type_annotations = MetadataFactory::new_array<AnnotationArray*>(

                                                   _loader_data, length, NULL,

                                                   CHECK_NULL);

         }

         _fields_type_annotations->at_put(n, parsed_annotations.field_type_annotations());

         parsed_annotations.set_field_type_annotations(NULL);

       }

       if (is_synthetic) {

         access_flags.set_is_synthetic();

       }

       if (generic_signature_index != 0) {

         access_flags.set_field_has_generic_signature();

         fa[generic_signature_slot] = generic_signature_index;

         generic_signature_slot ++;

         num_generic_signature ++;

       }

     }

     FieldInfo* field = FieldInfo::from_field_array(fa, n);

     field->initialize(access_flags.as_short(),

                       name_index,

                       signature_index,

                       constantvalue_index);

     BasicType type = _cp->basic_type_for_signature_at(signature_index);

     // Remember how many oops we encountered and compute allocation type

     FieldAllocationType atype = fac->update(is_static, type);

     field->set_allocation_type(atype);

     // After field is initialized with type, we can augment it with aux info

     if (parsed_annotations.has_any_annotations())

       parsed_annotations.apply_to(field);

   }

   int index = length;

   if (num_injected != 0) {

     for (int n = 0; n < num_injected; n++) {

       // Check for duplicates

       if (injected[n].may_be_java) {

         Symbol* name      = injected[n].name();

         Symbol* signature = injected[n].signature();

         bool duplicate = false;

         for (int i = 0; i < length; i++) {

           FieldInfo* f = FieldInfo::from_field_array(fa, i);

           if (name      == _cp->symbol_at(f->name_index()) &&

               signature == _cp->symbol_at(f->signature_index())) {

             // Symbol is desclared in Java so skip this one

             duplicate = true;

             break;

           }

         }

         if (duplicate) {

           // These will be removed from the field array at the end

           continue;

         }

       }

       // Injected field

       FieldInfo* field = FieldInfo::from_field_array(fa, index);

       field->initialize(JVM_ACC_FIELD_INTERNAL,

                         injected[n].name_index,

                         injected[n].signature_index,

                         0);

       BasicType type = FieldType::basic_type(injected[n].signature());

       // Remember how many oops we encountered and compute allocation type

       FieldAllocationType atype = fac->update(false, type);

       field->set_allocation_type(atype);

       index++;

     }

   }

   // Now copy the fields' data from the temporary resource array.

   // Sometimes injected fields already exist in the Java source so

   // the fields array could be too long.  In that case the

   // fields array is trimed. Also unused slots that were reserved

   // for generic signature indexes are discarded.

   Array<u2>* fields = MetadataFactory::new_array<u2>(

           _loader_data, index * FieldInfo::field_slots + num_generic_signature,

           CHECK_NULL);

   _fields = fields; // save in case of error

   {

     int i = 0;

     for (; i < index * FieldInfo::field_slots; i++) {

       fields->at_put(i, fa[i]);

     }

     for (int j = total_fields * FieldInfo::field_slots;

          j < generic_signature_slot; j++) {

       fields->at_put(i++, fa[j]);

     }

     assert(i == fields->length(), "");

   }

   if (_need_verify && length > 1) {

     // Check duplicated fields

     ResourceMark rm(THREAD);

     NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(

       THREAD, NameSigHash*, HASH_ROW_SIZE);

     initialize_hashtable(names_and_sigs);

     bool dup = false;

     {

       debug_only(No_Safepoint_Verifier nsv;)

       for (AllFieldStream fs(fields, _cp); !fs.done(); fs.next()) {

         Symbol* name = fs.name();

         Symbol* sig = fs.signature();

         // If no duplicates, add name/signature in hashtable names_and_sigs.

         if (!put_after_lookup(name, sig, names_and_sigs)) {

           dup = true;

           break;

         }

       }

     }

     if (dup) {

       classfile_parse_error("Duplicate field name&signature in class file %s",

                             CHECK_NULL);

     }

   }

   return fields;

 }

 static void copy_u2_with_conversion(u2* dest, u2* src, int length) {

   while (length-- > 0) {

     *dest++ = Bytes::get_Java_u2((u1*) (src++));

   }

 }

 u2* ClassFileParser::parse_exception_table(u4 code_length,

                                            u4 exception_table_length,

                                            TRAPS) {

   ClassFileStream* cfs = stream();

   u2* exception_table_start = cfs->get_u2_buffer();

   assert(exception_table_start != NULL, "null exception table");

   cfs->guarantee_more(8 * exception_table_length, CHECK_NULL); // start_pc, end_pc, handler_pc, catch_type_index

   // Will check legal target after parsing code array in verifier.

   if (_need_verify) {

     for (unsigned int i = 0; i < exception_table_length; i++) {

       u2 start_pc = cfs->get_u2_fast();

       u2 end_pc = cfs->get_u2_fast();

       u2 handler_pc = cfs->get_u2_fast();

       u2 catch_type_index = cfs->get_u2_fast();

       guarantee_property((start_pc < end_pc) && (end_pc <= code_length),

                          "Illegal exception table range in class file %s",

                          CHECK_NULL);

       guarantee_property(handler_pc < code_length,

                          "Illegal exception table handler in class file %s",

                          CHECK_NULL);

       if (catch_type_index != 0) {

         guarantee_property(valid_klass_reference_at(catch_type_index),

                            "Catch type in exception table has bad constant type in class file %s", CHECK_NULL);

       }

     }

   } else {

     cfs->skip_u2_fast(exception_table_length * 4);

   }

   return exception_table_start;

 }

 void ClassFileParser::parse_linenumber_table(

     u4 code_attribute_length, u4 code_length,

     CompressedLineNumberWriteStream** write_stream, TRAPS) {

   ClassFileStream* cfs = stream();

   unsigned int num_entries = cfs->get_u2(CHECK);

   // Each entry is a u2 start_pc, and a u2 line_number

   unsigned int length_in_bytes = num_entries * (sizeof(u2) + sizeof(u2));

   // Verify line number attribute and table length

   check_property(

     code_attribute_length == sizeof(u2) + length_in_bytes,

     "LineNumberTable attribute has wrong length in class file %s", CHECK);

   cfs->guarantee_more(length_in_bytes, CHECK);

   if ((*write_stream) == NULL) {

     if (length_in_bytes > fixed_buffer_size) {

       (*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes);

     } else {

       (*write_stream) = new CompressedLineNumberWriteStream(

         linenumbertable_buffer, fixed_buffer_size);

     }

   }

   while (num_entries-- > 0) {

     u2 bci  = cfs->get_u2_fast(); // start_pc

     u2 line = cfs->get_u2_fast(); // line_number

     guarantee_property(bci < code_length,

         "Invalid pc in LineNumberTable in class file %s", CHECK);

     (*write_stream)->write_pair(bci, line);

   }

 }

 // Class file LocalVariableTable elements.

 class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC {

  public:

   u2 start_bci;

   u2 length;

   u2 name_cp_index;

   u2 descriptor_cp_index;

   u2 slot;

 };

 class LVT_Hash: public CHeapObj<mtClass> {

  public:

   LocalVariableTableElement  *_elem;  // element

   LVT_Hash*                   _next;  // Next entry in hash table

 };

 unsigned int hash(LocalVariableTableElement *elem) {

   unsigned int raw_hash = elem->start_bci;

   raw_hash = elem->length        + raw_hash * 37;

   raw_hash = elem->name_cp_index + raw_hash * 37;

   raw_hash = elem->slot          + raw_hash * 37;

   return raw_hash % HASH_ROW_SIZE;

 }

 void initialize_hashtable(LVT_Hash** table) {

   for (int i = 0; i < HASH_ROW_SIZE; i++) {

     table[i] = NULL;

   }

 }

 void clear_hashtable(LVT_Hash** table) {

   for (int i = 0; i < HASH_ROW_SIZE; i++) {

     LVT_Hash* current = table[i];

     LVT_Hash* next;

     while (current != NULL) {

       next = current->_next;

       current->_next = NULL;

       delete(current);

       current = next;

     }

     table[i] = NULL;

   }

 }

 LVT_Hash* LVT_lookup(LocalVariableTableElement *elem, int index, LVT_Hash** table) {

   LVT_Hash* entry = table[index];

   /*

    * 3-tuple start_bci/length/slot has to be unique key,

    * so the following comparison seems to be redundant:

    *       && elem->name_cp_index == entry->_elem->name_cp_index

    */

   while (entry != NULL) {

     if (elem->start_bci           == entry->_elem->start_bci

      && elem->length              == entry->_elem->length

      && elem->name_cp_index       == entry->_elem->name_cp_index

      && elem->slot                == entry->_elem->slot

     ) {

       return entry;

     }

     entry = entry->_next;

   }

   return NULL;

 }

 // Return false if the local variable is found in table.

 // Return true if no duplicate is found.

 // And local variable is added as a new entry in table.

 bool LVT_put_after_lookup(LocalVariableTableElement *elem, LVT_Hash** table) {

   // First lookup for duplicates

   int index = hash(elem);

   LVT_Hash* entry = LVT_lookup(elem, index, table);

   if (entry != NULL) {

       return false;

   }

   // No duplicate is found, allocate a new entry and fill it.

   if ((entry = new LVT_Hash()) == NULL) {

     return false;

   }

   entry->_elem = elem;

   // Insert into hash table

   entry->_next = table[index];

   table[index] = entry;

   return true;

 }

 void copy_lvt_element(Classfile_LVT_Element *src, LocalVariableTableElement *lvt) {

   lvt->start_bci           = Bytes::get_Java_u2((u1*) &src->start_bci);

   lvt->length              = Bytes::get_Java_u2((u1*) &src->length);

   lvt->name_cp_index       = Bytes::get_Java_u2((u1*) &src->name_cp_index);

   lvt->descriptor_cp_index = Bytes::get_Java_u2((u1*) &src->descriptor_cp_index);

   lvt->signature_cp_index  = 0;

   lvt->slot                = Bytes::get_Java_u2((u1*) &src->slot);

 }

 // Function is used to parse both attributes:

 //       LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)

 u2* ClassFileParser::parse_localvariable_table(u4 code_length,

                                                u2 max_locals,

                                                u4 code_attribute_length,

                                                u2* localvariable_table_length,

                                                bool isLVTT,

                                                TRAPS) {

   ClassFileStream* cfs = stream();

   const char * tbl_name = (isLVTT) ? "LocalVariableTypeTable" : "LocalVariableTable";

   *localvariable_table_length = cfs->get_u2(CHECK_NULL);

   unsigned int size = (*localvariable_table_length) * sizeof(Classfile_LVT_Element) / sizeof(u2);

   // Verify local variable table attribute has right length

   if (_need_verify) {

     guarantee_property(code_attribute_length == (sizeof(*localvariable_table_length) + size * sizeof(u2)),

                        "%s has wrong length in class file %s", tbl_name, CHECK_NULL);

   }

   u2* localvariable_table_start = cfs->get_u2_buffer();

   assert(localvariable_table_start != NULL, "null local variable table");

   if (!_need_verify) {

     cfs->skip_u2_fast(size);

   } else {

     cfs->guarantee_more(size * 2, CHECK_NULL);

     for(int i = 0; i < (*localvariable_table_length); i++) {

       u2 start_pc = cfs->get_u2_fast();

       u2 length = cfs->get_u2_fast();

       u2 name_index = cfs->get_u2_fast();

       u2 descriptor_index = cfs->get_u2_fast();

       u2 index = cfs->get_u2_fast();

       // Assign to a u4 to avoid overflow

       u4 end_pc = (u4)start_pc + (u4)length;

       if (start_pc >= code_length) {

         classfile_parse_error(

           "Invalid start_pc %u in %s in class file %s",

           start_pc, tbl_name, CHECK_NULL);

       }

       if (end_pc > code_length) {

         classfile_parse_error(

           "Invalid length %u in %s in class file %s",

           length, tbl_name, CHECK_NULL);

       }

       int cp_size = _cp->length();

       guarantee_property(valid_symbol_at(name_index),

         "Name index %u in %s has bad constant type in class file %s",

         name_index, tbl_name, CHECK_NULL);

       guarantee_property(valid_symbol_at(descriptor_index),

         "Signature index %u in %s has bad constant type in class file %s",

         descriptor_index, tbl_name, CHECK_NULL);

       Symbol*  name = _cp->symbol_at(name_index);

       Symbol*  sig = _cp->symbol_at(descriptor_index);

       verify_legal_field_name(name, CHECK_NULL);

       u2 extra_slot = 0;

       if (!isLVTT) {

         verify_legal_field_signature(name, sig, CHECK_NULL);

         // 4894874: check special cases for double and long local variables

         if (sig == vmSymbols::type_signature(T_DOUBLE) ||

             sig == vmSymbols::type_signature(T_LONG)) {

           extra_slot = 1;

         }

       }

       guarantee_property((index + extra_slot) < max_locals,

                           "Invalid index %u in %s in class file %s",

                           index, tbl_name, CHECK_NULL);

     }

   }

   return localvariable_table_start;

 }

 void ClassFileParser::parse_type_array(u2 array_length, u4 code_length, u4* u1_index, u4* u2_index,

                                       u1* u1_array, u2* u2_array, TRAPS) {

   ClassFileStream* cfs = stream();

   u2 index = 0; // index in the array with long/double occupying two slots

   u4 i1 = *u1_index;

   u4 i2 = *u2_index + 1;

   for(int i = 0; i < array_length; i++) {

     u1 tag = u1_array[i1++] = cfs->get_u1(CHECK);

     index++;

     if (tag == ITEM_Long || tag == ITEM_Double) {

       index++;

     } else if (tag == ITEM_Object) {

       u2 class_index = u2_array[i2++] = cfs->get_u2(CHECK);

       guarantee_property(valid_klass_reference_at(class_index),

                          "Bad class index %u in StackMap in class file %s",

                          class_index, CHECK);

     } else if (tag == ITEM_Uninitialized) {

       u2 offset = u2_array[i2++] = cfs->get_u2(CHECK);

       guarantee_property(

         offset < code_length,

         "Bad uninitialized type offset %u in StackMap in class file %s",

         offset, CHECK);

     } else {

       guarantee_property(

         tag <= (u1)ITEM_Uninitialized,

         "Unknown variable type %u in StackMap in class file %s",

         tag, CHECK);

     }

   }

   u2_array[*u2_index] = index;

   *u1_index = i1;

   *u2_index = i2;

 }

 u1* ClassFileParser::parse_stackmap_table(

     u4 code_attribute_length, TRAPS) {

   if (code_attribute_length == 0)

     return NULL;

   ClassFileStream* cfs = stream();

   u1* stackmap_table_start = cfs->get_u1_buffer();

   assert(stackmap_table_start != NULL, "null stackmap table");

   // check code_attribute_length first

   stream()->skip_u1(code_attribute_length, CHECK_NULL);

   if (!_need_verify && !DumpSharedSpaces) {

     return NULL;

   }

   return stackmap_table_start;

 }

 u2* ClassFileParser::parse_checked_exceptions(u2* checked_exceptions_length,

                                               u4 method_attribute_length,

                                               TRAPS) {

   ClassFileStream* cfs = stream();

   cfs->guarantee_more(2, CHECK_NULL);  // checked_exceptions_length

   *checked_exceptions_length = cfs->get_u2_fast();

   unsigned int size = (*checked_exceptions_length) * sizeof(CheckedExceptionElement) / sizeof(u2);

   u2* checked_exceptions_start = cfs->get_u2_buffer();

   assert(checked_exceptions_start != NULL, "null checked exceptions");

   if (!_need_verify) {

     cfs->skip_u2_fast(size);

   } else {

     // Verify each value in the checked exception table

     u2 checked_exception;

     u2 len = *checked_exceptions_length;

     cfs->guarantee_more(2 * len, CHECK_NULL);

     for (int i = 0; i < len; i++) {

       checked_exception = cfs->get_u2_fast();

       check_property(

         valid_klass_reference_at(checked_exception),

         "Exception name has bad type at constant pool %u in class file %s",

         checked_exception, CHECK_NULL);

     }

   }

   // check exceptions attribute length

   if (_need_verify) {

     guarantee_property(method_attribute_length == (sizeof(*checked_exceptions_length) +

                                                    sizeof(u2) * size),

                       "Exceptions attribute has wrong length in class file %s", CHECK_NULL);

   }

   return checked_exceptions_start;

 }

 void ClassFileParser::throwIllegalSignature(

     const char* type, Symbol* name, Symbol* sig, TRAPS) {

   ResourceMark rm(THREAD);

   Exceptions::fthrow(THREAD_AND_LOCATION,

       vmSymbols::java_lang_ClassFormatError(),

       "%s \"%s\" in class %s has illegal signature \"%s\"", type,

       name->as_C_string(), _class_name->as_C_string(), sig->as_C_string());

 }

 // Skip an annotation.  Return >=limit if there is any problem.

 int ClassFileParser::skip_annotation(u1* buffer, int limit, int index) {

   // annotation := atype:u2 do(nmem:u2) {member:u2 value}

   // value := switch (tag:u1) { ... }

   index += 2;  // skip atype

   if ((index += 2) >= limit)  return limit;  // read nmem

   int nmem = Bytes::get_Java_u2(buffer+index-2);

   while (--nmem >= 0 && index < limit) {

     index += 2; // skip member

     index = skip_annotation_value(buffer, limit, index);

   }

   return index;

 }

 // Skip an annotation value.  Return >=limit if there is any problem.

 int ClassFileParser::skip_annotation_value(u1* buffer, int limit, int index) {

   // value := switch (tag:u1) {

   //   case B, C, I, S, Z, D, F, J, c: con:u2;

   //   case e: e_class:u2 e_name:u2;

   //   case s: s_con:u2;

   //   case [: do(nval:u2) {value};

   //   case @: annotation;

   //   case s: s_con:u2;

   // }

   if ((index += 1) >= limit)  return limit;  // read tag

   u1 tag = buffer[index-1];

   switch (tag) {

   case 'B': case 'C': case 'I': case 'S': case 'Z':

   case 'D': case 'F': case 'J': case 'c': case 's':

     index += 2;  // skip con or s_con

     break;

   case 'e':

     index += 4;  // skip e_class, e_name

     break;

   case '[':

     {

       if ((index += 2) >= limit)  return limit;  // read nval

       int nval = Bytes::get_Java_u2(buffer+index-2);

       while (--nval >= 0 && index < limit) {

         index = skip_annotation_value(buffer, limit, index);

       }

     }

     break;

   case '@':

     index = skip_annotation(buffer, limit, index);

     break;

   default:

     assert(false, "annotation tag");

     return limit;  //  bad tag byte

   }

   return index;

 }

 // Sift through annotations, looking for those significant to the VM:

 void ClassFileParser::parse_annotations(u1* buffer, int limit,

                                         ClassFileParser::AnnotationCollector* coll,

                                         TRAPS) {

   // annotations := do(nann:u2) {annotation}

   int index = 0;

   if ((index += 2) >= limit)  return;  // read nann

   int nann = Bytes::get_Java_u2(buffer+index-2);

   enum {  // initial annotation layout

     atype_off = 0,      // utf8 such as 'Ljava/lang/annotation/Retention;'

     count_off = 2,      // u2   such as 1 (one value)

     member_off = 4,     // utf8 such as 'value'

     tag_off = 6,        // u1   such as 'c' (type) or 'e' (enum)

     e_tag_val = 'e',

       e_type_off = 7,   // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;'

       e_con_off = 9,    // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME'

       e_size = 11,     // end of 'e' annotation

     c_tag_val = 'c',    // payload is type

       c_con_off = 7,    // utf8 payload, such as 'I'

       c_size = 9,       // end of 'c' annotation

     s_tag_val = 's',    // payload is String

       s_con_off = 7,    // utf8 payload, such as 'Ljava/lang/String;'

       s_size = 9,

     min_size = 6        // smallest possible size (zero members)

   };

   while ((--nann) >= 0 && (index-2 + min_size <= limit)) {

     int index0 = index;

     index = skip_annotation(buffer, limit, index);

     u1* abase = buffer + index0;

     int atype = Bytes::get_Java_u2(abase + atype_off);

     int count = Bytes::get_Java_u2(abase + count_off);

     Symbol* aname = check_symbol_at(_cp, atype);

     if (aname == NULL)  break;  // invalid annotation name

     Symbol* member = NULL;

     if (count >= 1) {

       int member_index = Bytes::get_Java_u2(abase + member_off);

       member = check_symbol_at(_cp, member_index);

       if (member == NULL)  break;  // invalid member name

     }

     // Here is where parsing particular annotations will take place.

     AnnotationCollector::ID id = coll->annotation_index(_loader_data, aname);

     if (id == AnnotationCollector::_unknown)  continue;

     coll->set_annotation(id);

     if (id == AnnotationCollector::_sun_misc_Contended) {

       // @Contended can optionally specify the contention group.

       //

       // Contended group defines the equivalence class over the fields:

       // the fields within the same contended group are not treated distinct.

       // The only exception is default group, which does not incur the

       // equivalence. Naturally, contention group for classes is meaningless.

       //

       // While the contention group is specified as String, annotation

       // values are already interned, and we might as well use the constant

       // pool index as the group tag.

       //

       u2 group_index = 0; // default contended group

       if (count == 1

           && s_size == (index - index0)  // match size

           && s_tag_val == *(abase + tag_off)

           && member == vmSymbols::value_name()) {

         group_index = Bytes::get_Java_u2(abase + s_con_off);

         if (_cp->symbol_at(group_index)->utf8_length() == 0) {

           group_index = 0; // default contended group

         }

       }

       coll->set_contended_group(group_index);

     }

   }

 }

 ClassFileParser::AnnotationCollector::ID

 ClassFileParser::AnnotationCollector::annotation_index(ClassLoaderData* loader_data,

                                                                 Symbol* name) {

   vmSymbols::SID sid = vmSymbols::find_sid(name);

   // Privileged code can use all annotations.  Other code silently drops some.

   const bool privileged = loader_data->is_the_null_class_loader_data() ||

                           loader_data->is_ext_class_loader_data() ||

                           loader_data->is_anonymous();

   switch (sid) {

   case vmSymbols::VM_SYMBOL_ENUM_NAME(sun_reflect_CallerSensitive_signature):

     if (_location != _in_method)  break;  // only allow for methods

     if (!privileged)              break;  // only allow in privileged code

     return _method_CallerSensitive;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_ForceInline_signature):

     if (_location != _in_method)  break;  // only allow for methods

     if (!privileged)              break;  // only allow in privileged code

     return _method_ForceInline;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_DontInline_signature):

     if (_location != _in_method)  break;  // only allow for methods

     if (!privileged)              break;  // only allow in privileged code

     return _method_DontInline;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_LambdaForm_Compiled_signature):

     if (_location != _in_method)  break;  // only allow for methods

     if (!privileged)              break;  // only allow in privileged code

     return _method_LambdaForm_Compiled;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_LambdaForm_Hidden_signature):

     if (_location != _in_method)  break;  // only allow for methods

     if (!privileged)              break;  // only allow in privileged code

     return _method_LambdaForm_Hidden;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_invoke_Stable_signature):

     if (_location != _in_field)   break;  // only allow for fields

     if (!privileged)              break;  // only allow in privileged code

     return _field_Stable;

   case vmSymbols::VM_SYMBOL_ENUM_NAME(sun_misc_Contended_signature):

     if (_location != _in_field && _location != _in_class)          break;  // only allow for fields and classes

     if (!EnableContended || (RestrictContended && !privileged))    break;  // honor privileges

     return _sun_misc_Contended;

   default: break;

   }

   return AnnotationCollector::_unknown;

 }

 void ClassFileParser::FieldAnnotationCollector::apply_to(FieldInfo* f) {

   if (is_contended())

     f->set_contended_group(contended_group());

   if (is_stable())

     f->set_stable(true);

 }

 ClassFileParser::FieldAnnotationCollector::~FieldAnnotationCollector() {

   // If there's an error deallocate metadata for field annotations

   MetadataFactory::free_array<u1>(_loader_data, _field_annotations);

   MetadataFactory::free_array<u1>(_loader_data, _field_type_annotations);

 }

 void ClassFileParser::MethodAnnotationCollector::apply_to(methodHandle m) {

   if (has_annotation(_method_CallerSensitive))

     m->set_caller_sensitive(true);

   if (has_annotation(_method_ForceInline))

     m->set_force_inline(true);

   if (has_annotation(_method_DontInline))

     m->set_dont_inline(true);

   if (has_annotation(_method_LambdaForm_Compiled) && m->intrinsic_id() == vmIntrinsics::_none)

     m->set_intrinsic_id(vmIntrinsics::_compiledLambdaForm);

   if (has_annotation(_method_LambdaForm_Hidden))

     m->set_hidden(true);

 }

 void ClassFileParser::ClassAnnotationCollector::apply_to(instanceKlassHandle k) {

   k->set_is_contended(is_contended());

 }

 #define MAX_ARGS_SIZE 255

 #define MAX_CODE_SIZE 65535

 #define INITIAL_MAX_LVT_NUMBER 256

 /* Copy class file LVT's/LVTT's into the HotSpot internal LVT.

  *

  * Rules for LVT's and LVTT's are:

  *   - There can be any number of LVT's and LVTT's.

  *   - If there are n LVT's, it is the same as if there was just

  *     one LVT containing all the entries from the n LVT's.

  *   - There may be no more than one LVT entry per local variable.

  *     Two LVT entries are 'equal' if these fields are the same:

  *        start_pc, length, name, slot

  *   - There may be no more than one LVTT entry per each LVT entry.

  *     Each LVTT entry has to match some LVT entry.

  *   - HotSpot internal LVT keeps natural ordering of class file LVT entries.

  */

 void ClassFileParser::copy_localvariable_table(ConstMethod* cm,

                                                int lvt_cnt,

                                                u2* localvariable_table_length,

                                                u2** localvariable_table_start,

                                                int lvtt_cnt,

                                                u2* localvariable_type_table_length,

                                                u2** localvariable_type_table_start,

                                                TRAPS) {

   LVT_Hash** lvt_Hash = NEW_RESOURCE_ARRAY(LVT_Hash*, HASH_ROW_SIZE);

   initialize_hashtable(lvt_Hash);

   // To fill LocalVariableTable in

   Classfile_LVT_Element*  cf_lvt;

   LocalVariableTableElement* lvt = cm->localvariable_table_start();

   for (int tbl_no = 0; tbl_no < lvt_cnt; tbl_no++) {

     cf_lvt = (Classfile_LVT_Element *) localvariable_table_start[tbl_no];

     for (int idx = 0; idx < localvariable_table_length[tbl_no]; idx++, lvt++) {

       copy_lvt_element(&cf_lvt[idx], lvt);

       // If no duplicates, add LVT elem in hashtable lvt_Hash.

       if (LVT_put_after_lookup(lvt, lvt_Hash) == false

           && _need_verify

           && _major_version >= JAVA_1_5_VERSION) {

         clear_hashtable(lvt_Hash);

         classfile_parse_error("Duplicated LocalVariableTable attribute "

                               "entry for '%s' in class file %s",

                                _cp->symbol_at(lvt->name_cp_index)->as_utf8(),

                                CHECK);

       }

     }

   }

   // To merge LocalVariableTable and LocalVariableTypeTable

   Classfile_LVT_Element* cf_lvtt;

   LocalVariableTableElement lvtt_elem;

   for (int tbl_no = 0; tbl_no < lvtt_cnt; tbl_no++) {

     cf_lvtt = (Classfile_LVT_Element *) localvariable_type_table_start[tbl_no];

     for (int idx = 0; idx < localvariable_type_table_length[tbl_no]; idx++) {

       copy_lvt_element(&cf_lvtt[idx], &lvtt_elem);

       int index = hash(&lvtt_elem);

       LVT_Hash* entry = LVT_lookup(&lvtt_elem, index, lvt_Hash);

       if (entry == NULL) {

         if (_need_verify) {

           clear_hashtable(lvt_Hash);

           classfile_parse_error("LVTT entry for '%s' in class file %s "

                                 "does not match any LVT entry",

                                  _cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),

                                  CHECK);

         }

       } else if (entry->_elem->signature_cp_index != 0 && _need_verify) {

         clear_hashtable(lvt_Hash);

         classfile_parse_error("Duplicated LocalVariableTypeTable attribute "

                               "entry for '%s' in class file %s",

                                _cp->symbol_at(lvtt_elem.name_cp_index)->as_utf8(),

                                CHECK);

       } else {

         // to add generic signatures into LocalVariableTable

         entry->_elem->signature_cp_index = lvtt_elem.descriptor_cp_index;

       }

     }

   }

   clear_hashtable(lvt_Hash);

 }

 void ClassFileParser::copy_method_annotations(ConstMethod* cm,

                                        u1* runtime_visible_annotations,

                                        int runtime_visible_annotations_length,

                                        u1* runtime_invisible_annotations,

                                        int runtime_invisible_annotations_length,

                                        u1* runtime_visible_parameter_annotations,

                                        int runtime_visible_parameter_annotations_length,

                                        u1* runtime_invisible_parameter_annotations,

                                        int runtime_invisible_parameter_annotations_length,

                                        u1* runtime_visible_type_annotations,

                                        int runtime_visible_type_annotations_length,

                                        u1* runtime_invisible_type_annotations,

                                        int runtime_invisible_type_annotations_length,

                                        u1* annotation_default,

                                        int annotation_default_length,

                                        TRAPS) {

   AnnotationArray* a;

   if (runtime_visible_annotations_length +

       runtime_invisible_annotations_length > 0) {

      a = assemble_annotations(runtime_visible_annotations,

                               runtime_visible_annotations_length,

                               runtime_invisible_annotations,

                               runtime_invisible_annotations_length,

                               CHECK);

      cm->set_method_annotations(a);

   }

   if (runtime_visible_parameter_annotations_length +

       runtime_invisible_parameter_annotations_length > 0) {

     a = assemble_annotations(runtime_visible_parameter_annotations,

                              runtime_visible_parameter_annotations_length,

                              runtime_invisible_parameter_annotations,

                              runtime_invisible_parameter_annotations_length,

                              CHECK);

     cm->set_parameter_annotations(a);

   }

   if (annotation_default_length > 0) {

     a = assemble_annotations(annotation_default,

                              annotation_default_length,

                              NULL,

                              0,

                              CHECK);

     cm->set_default_annotations(a);

   }

   if (runtime_visible_type_annotations_length +

       runtime_invisible_type_annotations_length > 0) {

     a = assemble_annotations(runtime_visible_type_annotations,

                              runtime_visible_type_annotations_length,

                              runtime_invisible_type_annotations,

                              runtime_invisible_type_annotations_length,

                              CHECK);

     cm->set_type_annotations(a);

   }

 }

 // Note: the parse_method below is big and clunky because all parsing of the code and exceptions

 // attribute is inlined. This is cumbersome to avoid since we inline most of the parts in the

 // Method* to save footprint, so we only know the size of the resulting Method* when the

 // entire method attribute is parsed.

 //

 // The promoted_flags parameter is used to pass relevant access_flags

 // from the method back up to the containing klass. These flag values

 // are added to klass's access_flags.

 methodHandle ClassFileParser::parse_method(bool is_interface,

                                            AccessFlags *promoted_flags,

                                            TRAPS) {

   ClassFileStream* cfs = stream();

   methodHandle nullHandle;

   ResourceMark rm(THREAD);

   // Parse fixed parts

   cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count

   int flags = cfs->get_u2_fast();

   u2 name_index = cfs->get_u2_fast();

   int cp_size = _cp->length();

   check_property(

     valid_symbol_at(name_index),

     "Illegal constant pool index %u for method name in class file %s",

     name_index, CHECK_(nullHandle));

   Symbol*  name = _cp->symbol_at(name_index);

   verify_legal_method_name(name, CHECK_(nullHandle));

   u2 signature_index = cfs->get_u2_fast();

   guarantee_property(

     valid_symbol_at(signature_index),

     "Illegal constant pool index %u for method signature in class file %s",

     signature_index, CHECK_(nullHandle));

   Symbol*  signature = _cp->symbol_at(signature_index);

   AccessFlags access_flags;

   if (name == vmSymbols::class_initializer_name()) {

     // We ignore the other access flags for a valid class initializer.

     // (JVM Spec 2nd ed., chapter 4.6)

     if (_major_version < 51) { // backward compatibility

       flags = JVM_ACC_STATIC;

     } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) {

       flags &= JVM_ACC_STATIC | JVM_ACC_STRICT;

     }

   } else {

     verify_legal_method_modifiers(flags, is_interface, name, CHECK_(nullHandle));

   }

   int args_size = -1;  // only used when _need_verify is true

   if (_need_verify) {

     args_size = ((flags & JVM_ACC_STATIC) ? 0 : 1) +

                  verify_legal_method_signature(name, signature, CHECK_(nullHandle));

     if (args_size > MAX_ARGS_SIZE) {

       classfile_parse_error("Too many arguments in method signature in class file %s", CHECK_(nullHandle));

     }

   }

   access_flags.set_flags(flags & JVM_RECOGNIZED_METHOD_MODIFIERS);

   // Default values for code and exceptions attribute elements

   u2 max_stack = 0;

   u2 max_locals = 0;

   u4 code_length = 0;

   u1* code_start = 0;

   u2 exception_table_length = 0;

   u2* exception_table_start = NULL;

   Array<int>* exception_handlers = Universe::the_empty_int_array();

   u2 checked_exceptions_length = 0;

   u2* checked_exceptions_start = NULL;

   CompressedLineNumberWriteStream* linenumber_table = NULL;

   int linenumber_table_length = 0;

   int total_lvt_length = 0;

   u2 lvt_cnt = 0;

   u2 lvtt_cnt = 0;

   bool lvt_allocated = false;

   u2 max_lvt_cnt = INITIAL_MAX_LVT_NUMBER;

   u2 max_lvtt_cnt = INITIAL_MAX_LVT_NUMBER;

   u2* localvariable_table_length;

   u2** localvariable_table_start;

   u2* localvariable_type_table_length;

   u2** localvariable_type_table_start;

   u2 method_parameters_length = 0;

   u1* method_parameters_data = NULL;

   bool method_parameters_seen = false;

   bool parsed_code_attribute = false;

   bool parsed_checked_exceptions_attribute = false;

   bool parsed_stackmap_attribute = false;

   // stackmap attribute - JDK1.5

   u1* stackmap_data = NULL;

   int stackmap_data_length = 0;

   u2 generic_signature_index = 0;

   MethodAnnotationCollector parsed_annotations;

   u1* runtime_visible_annotations = NULL;

   int runtime_visible_annotations_length = 0;

   u1* runtime_invisible_annotations = NULL;

   int runtime_invisible_annotations_length = 0;

   u1* runtime_visible_parameter_annotations = NULL;

   int runtime_visible_parameter_annotations_length = 0;

   u1* runtime_invisible_parameter_annotations = NULL;

   int runtime_invisible_parameter_annotations_length = 0;

   u1* runtime_visible_type_annotations = NULL;

   int runtime_visible_type_annotations_length = 0;

   u1* runtime_invisible_type_annotations = NULL;

   int runtime_invisible_type_annotations_length = 0;

   bool runtime_invisible_type_annotations_exists = false;

   u1* annotation_default = NULL;

   int annotation_default_length = 0;

   // Parse code and exceptions attribute

   u2 method_attributes_count = cfs->get_u2_fast();

   while (method_attributes_count--) {

     cfs->guarantee_more(6, CHECK_(nullHandle));  // method_attribute_name_index, method_attribute_length

     u2 method_attribute_name_index = cfs->get_u2_fast();

     u4 method_attribute_length = cfs->get_u4_fast();

     check_property(

       valid_symbol_at(method_attribute_name_index),

       "Invalid method attribute name index %u in class file %s",

       method_attribute_name_index, CHECK_(nullHandle));

     Symbol* method_attribute_name = _cp->symbol_at(method_attribute_name_index);

     if (method_attribute_name == vmSymbols::tag_code()) {

       // Parse Code attribute

       if (_need_verify) {

         guarantee_property(

             !access_flags.is_native() && !access_flags.is_abstract(),

                         "Code attribute in native or abstract methods in class file %s",

                          CHECK_(nullHandle));

       }

       if (parsed_code_attribute) {

         classfile_parse_error("Multiple Code attributes in class file %s", CHECK_(nullHandle));

       }

       parsed_code_attribute = true;

       // Stack size, locals size, and code size

       if (_major_version == 45 && _minor_version <= 2) {

         cfs->guarantee_more(4, CHECK_(nullHandle));

         max_stack = cfs->get_u1_fast();

         max_locals = cfs->get_u1_fast();

         code_length = cfs->get_u2_fast();

       } else {

         cfs->guarantee_more(8, CHECK_(nullHandle));

         max_stack = cfs->get_u2_fast();

         max_locals = cfs->get_u2_fast();

         code_length = cfs->get_u4_fast();

       }

       if (_need_verify) {

         guarantee_property(args_size <= max_locals,

                            "Arguments can't fit into locals in class file %s", CHECK_(nullHandle));

         guarantee_property(code_length > 0 && code_length <= MAX_CODE_SIZE,

                            "Invalid method Code length %u in class file %s",

                            code_length, CHECK_(nullHandle));

       }

       // Code pointer

       code_start = cfs->get_u1_buffer();

       assert(code_start != NULL, "null code start");

       cfs->guarantee_more(code_length, CHECK_(nullHandle));

       cfs->skip_u1_fast(code_length);

       // Exception handler table

       cfs->guarantee_more(2, CHECK_(nullHandle));  // exception_table_length

       exception_table_length = cfs->get_u2_fast();

       if (exception_table_length > 0) {

         exception_table_start =

               parse_exception_table(code_length, exception_table_length, CHECK_(nullHandle));

       }

       // Parse additional attributes in code attribute

       cfs->guarantee_more(2, CHECK_(nullHandle));  // code_attributes_count

       u2 code_attributes_count = cfs->get_u2_fast();

       unsigned int calculated_attribute_length = 0;

       if (_major_version > 45 || (_major_version == 45 && _minor_version > 2)) {

         calculated_attribute_length =

             sizeof(max_stack) + sizeof(max_locals) + sizeof(code_length);

       } else {

         // max_stack, locals and length are smaller in pre-version 45.2 classes

         calculated_attribute_length = sizeof(u1) + sizeof(u1) + sizeof(u2);

       }

       calculated_attribute_length +=

         code_length +

         sizeof(exception_table_length) +

         sizeof(code_attributes_count) +

         exception_table_length *

             ( sizeof(u2) +   // start_pc

               sizeof(u2) +   // end_pc

               sizeof(u2) +   // handler_pc

               sizeof(u2) );  // catch_type_index

       while (code_attributes_count--) {

         cfs->guarantee_more(6, CHECK_(nullHandle));  // code_attribute_name_index, code_attribute_length

         u2 code_attribute_name_index = cfs->get_u2_fast();

         u4 code_attribute_length = cfs->get_u4_fast();

         calculated_attribute_length += code_attribute_length +

                                        sizeof(code_attribute_name_index) +

                                        sizeof(code_attribute_length);

         check_property(valid_symbol_at(code_attribute_name_index),

                        "Invalid code attribute name index %u in class file %s",

                        code_attribute_name_index,

                        CHECK_(nullHandle));

         if (LoadLineNumberTables &&

             _cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_line_number_table()) {

           // Parse and compress line number table

           parse_linenumber_table(code_attribute_length, code_length,

             &linenumber_table, CHECK_(nullHandle));

         } else if (LoadLocalVariableTables &&

                    _cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_table()) {

           // Parse local variable table

           if (!lvt_allocated) {

             localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2,  INITIAL_MAX_LVT_NUMBER);

             localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2*, INITIAL_MAX_LVT_NUMBER);

             localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2,  INITIAL_MAX_LVT_NUMBER);

             localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2*, INITIAL_MAX_LVT_NUMBER);

             lvt_allocated = true;

           }

           if (lvt_cnt == max_lvt_cnt) {

             max_lvt_cnt <<= 1;

             localvariable_table_length = REALLOC_RESOURCE_ARRAY(u2, localvariable_table_length, lvt_cnt, max_lvt_cnt);

             localvariable_table_start  = REALLOC_RESOURCE_ARRAY(u2*, localvariable_table_start, lvt_cnt, max_lvt_cnt);

           }

           localvariable_table_start[lvt_cnt] =

             parse_localvariable_table(code_length,

                                       max_locals,

                                       code_attribute_length,

                                       &localvariable_table_length[lvt_cnt],

                                       false,    // is not LVTT

                                       CHECK_(nullHandle));

           total_lvt_length += localvariable_table_length[lvt_cnt];

           lvt_cnt++;

         } else if (LoadLocalVariableTypeTables &&

                    _major_version >= JAVA_1_5_VERSION &&

                    _cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_local_variable_type_table()) {

           if (!lvt_allocated) {

             localvariable_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2,  INITIAL_MAX_LVT_NUMBER);

             localvariable_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2*, INITIAL_MAX_LVT_NUMBER);

             localvariable_type_table_length = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2,  INITIAL_MAX_LVT_NUMBER);

             localvariable_type_table_start = NEW_RESOURCE_ARRAY_IN_THREAD(

               THREAD, u2*, INITIAL_MAX_LVT_NUMBER);

             lvt_allocated = true;

           }

           // Parse local variable type table

           if (lvtt_cnt == max_lvtt_cnt) {

             max_lvtt_cnt <<= 1;

             localvariable_type_table_length = REALLOC_RESOURCE_ARRAY(u2, localvariable_type_table_length, lvtt_cnt, max_lvtt_cnt);

             localvariable_type_table_start  = REALLOC_RESOURCE_ARRAY(u2*, localvariable_type_table_start, lvtt_cnt, max_lvtt_cnt);

           }

           localvariable_type_table_start[lvtt_cnt] =

             parse_localvariable_table(code_length,

                                       max_locals,

                                       code_attribute_length,

                                       &localvariable_type_table_length[lvtt_cnt],

                                       true,     // is LVTT

                                       CHECK_(nullHandle));

           lvtt_cnt++;

         } else if (_major_version >= Verifier::STACKMAP_ATTRIBUTE_MAJOR_VERSION &&

                    _cp->symbol_at(code_attribute_name_index) == vmSymbols::tag_stack_map_table()) {

           // Stack map is only needed by the new verifier in JDK1.5.

           if (parsed_stackmap_attribute) {

             classfile_parse_error("Multiple StackMapTable attributes in class file %s", CHECK_(nullHandle));

           }

           stackmap_data = parse_stackmap_table(code_attribute_length, CHECK_(nullHandle));

           stackmap_data_length = code_attribute_length;

           parsed_stackmap_attribute = true;

         } else {

           // Skip unknown attributes

           cfs->skip_u1(code_attribute_length, CHECK_(nullHandle));

         }

       }

       // check method attribute length

       if (_need_verify) {

         guarantee_property(method_attribute_length == calculated_attribute_length,

                            "Code segment has wrong length in class file %s", CHECK_(nullHandle));

       }

     } else if (method_attribute_name == vmSymbols::tag_exceptions()) {

       // Parse Exceptions attribute

       if (parsed_checked_exceptions_attribute) {

         classfile_parse_error("Multiple Exceptions attributes in class file %s", CHECK_(nullHandle));

       }

       parsed_checked_exceptions_attribute = true;

       checked_exceptions_start =

             parse_checked_exceptions(&checked_exceptions_length,

                                      method_attribute_length,

                                      CHECK_(nullHandle));

     } else if (method_attribute_name == vmSymbols::tag_method_parameters()) {

       // reject multiple method parameters

       if (method_parameters_seen) {

         classfile_parse_error("Multiple MethodParameters attributes in class file %s", CHECK_(nullHandle));

       }

       method_parameters_seen = true;

       method_parameters_length = cfs->get_u1_fast();

       if (method_attribute_length != (method_parameters_length * 4u) + 1u) {

         classfile_parse_error(

           "Invalid MethodParameters method attribute length %u in class file",

           method_attribute_length, CHECK_(nullHandle));

       }

       method_parameters_data = cfs->get_u1_buffer();

       cfs->skip_u2_fast(method_parameters_length);

       cfs->skip_u2_fast(method_parameters_length);

       // ignore this attribute if it cannot be reflected

       if (!SystemDictionary::Parameter_klass_loaded())

         method_parameters_length = 0;

     } else if (method_attribute_name == vmSymbols::tag_synthetic()) {

       if (method_attribute_length != 0) {

         classfile_parse_error(

           "Invalid Synthetic method attribute length %u in class file %s",

           method_attribute_length, CHECK_(nullHandle));

       }

       // Should we check that there hasn't already been a synthetic attribute?

       access_flags.set_is_synthetic();

     } else if (method_attribute_name == vmSymbols::tag_deprecated()) { // 4276120

       if (method_attribute_length != 0) {

         classfile_parse_error(

           "Invalid Deprecated method attribute length %u in class file %s",

           method_attribute_length, CHECK_(nullHandle));

       }

     } else if (_major_version >= JAVA_1_5_VERSION) {

       if (method_attribute_name == vmSymbols::tag_signature()) {

         if (method_attribute_length != 2) {

           classfile_parse_error(

             "Invalid Signature attribute length %u in class file %s",

             method_attribute_length, CHECK_(nullHandle));

         }

         generic_signature_index = parse_generic_signature_attribute(CHECK_(nullHandle));

       } else if (method_attribute_name == vmSymbols::tag_runtime_visible_annotations()) {

         runtime_visible_annotations_length = method_attribute_length;

         runtime_visible_annotations = cfs->get_u1_buffer();

         assert(runtime_visible_annotations != NULL, "null visible annotations");

         parse_annotations(runtime_visible_annotations,

             runtime_visible_annotations_length, &parsed_annotations,

             CHECK_(nullHandle));

         cfs->skip_u1(runtime_visible_annotations_length, CHECK_(nullHandle));

       } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_annotations()) {

         runtime_invisible_annotations_length = method_attribute_length;

         runtime_invisible_annotations = cfs->get_u1_buffer();

         assert(runtime_invisible_annotations != NULL, "null invisible annotations");

         cfs->skip_u1(runtime_invisible_annotations_length, CHECK_(nullHandle));

       } else if (method_attribute_name == vmSymbols::tag_runtime_visible_parameter_annotations()) {

         runtime_visible_parameter_annotations_length = method_attribute_length;

         runtime_visible_parameter_annotations = cfs->get_u1_buffer();

         assert(runtime_visible_parameter_annotations != NULL, "null visible parameter annotations");

         cfs->skip_u1(runtime_visible_parameter_annotations_length, CHECK_(nullHandle));

       } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_parameter_annotations()) {

         runtime_invisible_parameter_annotations_length = method_attribute_length;

         runtime_invisible_parameter_annotations = cfs->get_u1_buffer();

         assert(runtime_invisible_parameter_annotations != NULL, "null invisible parameter annotations");

         cfs->skip_u1(runtime_invisible_parameter_annotations_length, CHECK_(nullHandle));

       } else if (method_attribute_name == vmSymbols::tag_annotation_default()) {

         annotation_default_length = method_attribute_length;

         annotation_default = cfs->get_u1_buffer();

         assert(annotation_default != NULL, "null annotation default");

         cfs->skip_u1(annotation_default_length, CHECK_(nullHandle));

       } else if (method_attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) {

         if (runtime_visible_type_annotations != NULL) {

           classfile_parse_error(

             "Multiple RuntimeVisibleTypeAnnotations attributes for method in class file %s",

             CHECK_(nullHandle));

         }

         runtime_visible_type_annotations_length = method_attribute_length;

         runtime_visible_type_annotations = cfs->get_u1_buffer();

         assert(runtime_visible_type_annotations != NULL, "null visible type annotations");

         // No need for the VM to parse Type annotations

         cfs->skip_u1(runtime_visible_type_annotations_length, CHECK_(nullHandle));

       } else if (method_attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {

         if (runtime_invisible_type_annotations_exists) {

           classfile_parse_error(

             "Multiple RuntimeInvisibleTypeAnnotations attributes for method in class file %s",

             CHECK_(nullHandle));

         } else {

           runtime_invisible_type_annotations_exists = true;

         }

         if (PreserveAllAnnotations) {

           runtime_invisible_type_annotations_length = method_attribute_length;

           runtime_invisible_type_annotations = cfs->get_u1_buffer();

           assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");

         }

         cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));

       } else {

         // Skip unknown attributes

         cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));

       }

     } else {

       // Skip unknown attributes

       cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));

     }

   }

   if (linenumber_table != NULL) {

     linenumber_table->write_terminator();

     linenumber_table_length = linenumber_table->position();

   }

   // Make sure there's at least one Code attribute in non-native/non-abstract method

   if (_need_verify) {

     guarantee_property(access_flags.is_native() || access_flags.is_abstract() || parsed_code_attribute,

                       "Absent Code attribute in method that is not native or abstract in class file %s", CHECK_(nullHandle));

   }

   // All sizing information for a Method* is finally available, now create it

   InlineTableSizes sizes(

       total_lvt_length,

       linenumber_table_length,

       exception_table_length,

       checked_exceptions_length,

       method_parameters_length,

       generic_signature_index,

       runtime_visible_annotations_length +

            runtime_invisible_annotations_length,

       runtime_visible_parameter_annotations_length +

            runtime_invisible_parameter_annotations_length,

       runtime_visible_type_annotations_length +

            runtime_invisible_type_annotations_length,

       annotation_default_length,

       0);

   Method* m = Method::allocate(

       _loader_data, code_length, access_flags, &sizes,

       ConstMethod::NORMAL, CHECK_(nullHandle));

   ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);

   // Fill in information from fixed part (access_flags already set)

   m->set_constants(_cp);

   m->set_name_index(name_index);

   m->set_signature_index(signature_index);

 #ifdef CC_INTERP

   // hmm is there a gc issue here??

   ResultTypeFinder rtf(_cp->symbol_at(signature_index));

   m->set_result_index(rtf.type());

 #endif

   if (args_size >= 0) {

     m->set_size_of_parameters(args_size);

   } else {

     m->compute_size_of_parameters(THREAD);

   }

 #ifdef ASSERT

   if (args_size >= 0) {

     m->compute_size_of_parameters(THREAD);

     assert(args_size == m->size_of_parameters(), "");

   }

 #endif

   // Fill in code attribute information

   m->set_max_stack(max_stack);

   m->set_max_locals(max_locals);

   if (stackmap_data != NULL) {

     m->constMethod()->copy_stackmap_data(_loader_data, stackmap_data,

                                          stackmap_data_length, CHECK_NULL);

   }

   // Copy byte codes

   m->set_code(code_start);

   // Copy line number table

   if (linenumber_table != NULL) {

     memcpy(m->compressed_linenumber_table(),

            linenumber_table->buffer(), linenumber_table_length);

   }

   // Copy exception table

   if (exception_table_length > 0) {

     int size =

       exception_table_length * sizeof(ExceptionTableElement) / sizeof(u2);

     copy_u2_with_conversion((u2*) m->exception_table_start(),

                              exception_table_start, size);

   }

   // Copy method parameters

   if (method_parameters_length > 0) {

     MethodParametersElement* elem = m->constMethod()->method_parameters_start();

     for (int i = 0; i < method_parameters_length; i++) {

       elem[i].name_cp_index = Bytes::get_Java_u2(method_parameters_data);

       method_parameters_data += 2;

       elem[i].flags = Bytes::get_Java_u2(method_parameters_data);

       method_parameters_data += 2;

     }

   }

   // Copy checked exceptions

   if (checked_exceptions_length > 0) {

     int size = checked_exceptions_length * sizeof(CheckedExceptionElement) / sizeof(u2);

     copy_u2_with_conversion((u2*) m->checked_exceptions_start(), checked_exceptions_start, size);

   }

   // Copy class file LVT's/LVTT's into the HotSpot internal LVT.

   if (total_lvt_length > 0) {

     promoted_flags->set_has_localvariable_table();

     copy_localvariable_table(m->constMethod(), lvt_cnt,

                              localvariable_table_length,

                              localvariable_table_start,

                              lvtt_cnt,

                              localvariable_type_table_length,

                              localvariable_type_table_start, CHECK_NULL);

   }

   if (parsed_annotations.has_any_annotations())

     parsed_annotations.apply_to(m);

   // Copy annotations

   copy_method_annotations(m->constMethod(),

                           runtime_visible_annotations,

                           runtime_visible_annotations_length,

                           runtime_invisible_annotations,

                           runtime_invisible_annotations_length,

                           runtime_visible_parameter_annotations,

                           runtime_visible_parameter_annotations_length,

                           runtime_invisible_parameter_annotations,

                           runtime_invisible_parameter_annotations_length,

                           runtime_visible_type_annotations,

                           runtime_visible_type_annotations_length,

                           runtime_invisible_type_annotations,

                           runtime_invisible_type_annotations_length,

                           annotation_default,

                           annotation_default_length,

                           CHECK_NULL);

   if (name == vmSymbols::finalize_method_name() &&

       signature == vmSymbols::void_method_signature()) {

     if (m->is_empty_method()) {

       _has_empty_finalizer = true;

     } else {

       _has_finalizer = true;

     }

   }

   if (name == vmSymbols::object_initializer_name() &&

       signature == vmSymbols::void_method_signature() &&

       m->is_vanilla_constructor()) {

     _has_vanilla_constructor = true;

   }

   NOT_PRODUCT(m->verify());

   return m;

 }

 // The promoted_flags parameter is used to pass relevant access_flags

 // from the methods back up to the containing klass. These flag values

 // are added to klass's access_flags.

 Array<Method*>* ClassFileParser::parse_methods(bool is_interface,

                                                AccessFlags* promoted_flags,

                                                bool* has_final_method,

                                                bool* has_default_methods,

                                                TRAPS) {

   ClassFileStream* cfs = stream();

   cfs->guarantee_more(2, CHECK_NULL);  // length

   u2 length = cfs->get_u2_fast();

   if (length == 0) {

     _methods = Universe::the_empty_method_array();

   } else {

     _methods = MetadataFactory::new_array<Method*>(_loader_data, length, NULL, CHECK_NULL);

     HandleMark hm(THREAD);

     for (int index = 0; index < length; index++) {

       methodHandle method = parse_method(is_interface,

                                          promoted_flags,

                                          CHECK_NULL);

       if (method->is_final()) {

         *has_final_method = true;

       }

       if (is_interface && !(*has_default_methods)

         && !method->is_abstract() && !method->is_static()

         && !method->is_private()) {

         // default method

         *has_default_methods = true;

       }

       _methods->at_put(index, method());

     }

     if (_need_verify && length > 1) {

       // Check duplicated methods

       ResourceMark rm(THREAD);

       NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(

         THREAD, NameSigHash*, HASH_ROW_SIZE);

       initialize_hashtable(names_and_sigs);

       bool dup = false;

       {

         debug_only(No_Safepoint_Verifier nsv;)

         for (int i = 0; i < length; i++) {

           Method* m = _methods->at(i);

           // If no duplicates, add name/signature in hashtable names_and_sigs.

           if (!put_after_lookup(m->name(), m->signature(), names_and_sigs)) {

             dup = true;

             break;

           }

         }

       }

       if (dup) {

         classfile_parse_error("Duplicate method name&signature in class file %s",

                               CHECK_NULL);

       }

     }

   }

   return _methods;

 }

 intArray* ClassFileParser::sort_methods(Array<Method*>* methods) {

   int length = methods->length();

   // If JVMTI original method ordering or sharing is enabled we have to

   // remember the original class file ordering.

   // We temporarily use the vtable_index field in the Method* to store the

   // class file index, so we can read in after calling qsort.

   // Put the method ordering in the shared archive.

   if (JvmtiExport::can_maintain_original_method_order() || DumpSharedSpaces) {

     for (int index = 0; index < length; index++) {

       Method* m = methods->at(index);

       assert(!m->valid_vtable_index(), "vtable index should not be set");

       m->set_vtable_index(index);

     }

   }

   // Sort method array by ascending method name (for faster lookups & vtable construction)

   // Note that the ordering is not alphabetical, see Symbol::fast_compare

   Method::sort_methods(methods);

   intArray* method_ordering = NULL;

   // If JVMTI original method ordering or sharing is enabled construct int

   // array remembering the original ordering

   if (JvmtiExport::can_maintain_original_method_order() || DumpSharedSpaces) {

     method_ordering = new intArray(length);

     for (int index = 0; index < length; index++) {

       Method* m = methods->at(index);

       int old_index = m->vtable_index();

       assert(old_index >= 0 && old_index < length, "invalid method index");

       method_ordering->at_put(index, old_index);

       m->set_vtable_index(Method::invalid_vtable_index);

     }

   }

   return method_ordering;

 }

 // Parse generic_signature attribute for methods and fields

 u2 ClassFileParser::parse_generic_signature_attribute(TRAPS) {

   ClassFileStream* cfs = stream();

   cfs->guarantee_more(2, CHECK_0);  // generic_signature_index

   u2 generic_signature_index = cfs->get_u2_fast();

   check_property(

     valid_symbol_at(generic_signature_index),

     "Invalid Signature attribute at constant pool index %u in class file %s",

     generic_signature_index, CHECK_0);

   return generic_signature_index;

 }

 void ClassFileParser::parse_classfile_sourcefile_attribute(TRAPS) {

   ClassFileStream* cfs = stream();

   cfs->guarantee_more(2, CHECK);  // sourcefile_index

   u2 sourcefile_index = cfs->get_u2_fast();

   check_property(

     valid_symbol_at(sourcefile_index),

     "Invalid SourceFile attribute at constant pool index %u in class file %s",

     sourcefile_index, CHECK);

   set_class_sourcefile_index(sourcefile_index);

 }