1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_classFileParser.cpp.incl"

    27 

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

    29 // temporary data structures and copying the bytes twice. A temporary area is only

    30 // needed when parsing utf8 entries in the constant pool and when parsing line number

    31 // tables.

    32 

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

    34 

    35 #define JAVA_CLASSFILE_MAGIC              0xCAFEBABE

    36 #define JAVA_MIN_SUPPORTED_VERSION        45

    37 #define JAVA_MAX_SUPPORTED_VERSION        50

    38 #define JAVA_MAX_SUPPORTED_MINOR_VERSION  0

    39 

    40 // Used for two backward compatibility reasons:

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

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

    43 #define JAVA_1_5_VERSION                  49

    44 

    45 // Used for backward compatibility reasons:

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

    47 #define JAVA_6_VERSION                    50

    48 

    49 

    50 void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, int length, TRAPS) {

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

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

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

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

    55   // this method that uses stream().

    56   ClassFileStream* cfs0 = stream();

    57   ClassFileStream cfs1 = *cfs0;

    58   ClassFileStream* cfs = &cfs1;

    59 #ifdef ASSERT

    60   u1* old_current = cfs0->current();

    61 #endif

    62 

    63   // Used for batching symbol allocations.

    64   const char* names[SymbolTable::symbol_alloc_batch_size];

    65   int lengths[SymbolTable::symbol_alloc_batch_size];

    66   int indices[SymbolTable::symbol_alloc_batch_size];

    67   unsigned int hashValues[SymbolTable::symbol_alloc_batch_size];

    68   int names_count = 0;

    69 

    70   // parsing  Index 0 is unused

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

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

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

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

    75     u1 tag = cfs->get_u1_fast();

    76     switch (tag) {

    77       case JVM_CONSTANT_Class :

    78         {

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

    80           u2 name_index = cfs->get_u2_fast();

    81           cp->klass_index_at_put(index, name_index);

    82         }

    83         break;

    84       case JVM_CONSTANT_Fieldref :

    85         {

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

    87           u2 class_index = cfs->get_u2_fast();

    88           u2 name_and_type_index = cfs->get_u2_fast();

    89           cp->field_at_put(index, class_index, name_and_type_index);

    90         }

    91         break;

    92       case JVM_CONSTANT_Methodref :

    93         {

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

    95           u2 class_index = cfs->get_u2_fast();

    96           u2 name_and_type_index = cfs->get_u2_fast();

    97           cp->method_at_put(index, class_index, name_and_type_index);

    98         }

    99         break;

   100       case JVM_CONSTANT_InterfaceMethodref :

   101         {

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

   103           u2 class_index = cfs->get_u2_fast();

   104           u2 name_and_type_index = cfs->get_u2_fast();

   105           cp->interface_method_at_put(index, class_index, name_and_type_index);

   106         }

   107         break;

   108       case JVM_CONSTANT_String :

   109         {

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

   111           u2 string_index = cfs->get_u2_fast();

   112           cp->string_index_at_put(index, string_index);

   113         }

   114         break;

   115       case JVM_CONSTANT_Integer :

   116         {

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

   118           u4 bytes = cfs->get_u4_fast();

   119           cp->int_at_put(index, (jint) bytes);

   120         }

   121         break;

   122       case JVM_CONSTANT_Float :

   123         {

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

   125           u4 bytes = cfs->get_u4_fast();

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

   127         }

   128         break;

   129       case JVM_CONSTANT_Long :

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

   131         guarantee_property(index+1 < length,

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

   133                            index, CHECK);

   134         {

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

   136           u8 bytes = cfs->get_u8_fast();

   137           cp->long_at_put(index, bytes);

   138         }

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

   140         break;

   141       case JVM_CONSTANT_Double :

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

   143         guarantee_property(index+1 < length,

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

   145                            index, CHECK);

   146         {

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

   148           u8 bytes = cfs->get_u8_fast();

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

   150         }

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

   152         break;

   153       case JVM_CONSTANT_NameAndType :

   154         {

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

   156           u2 name_index = cfs->get_u2_fast();

   157           u2 signature_index = cfs->get_u2_fast();

   158           cp->name_and_type_at_put(index, name_index, signature_index);

   159         }

   160         break;

   161       case JVM_CONSTANT_Utf8 :

   162         {

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

   164           u2  utf8_length = cfs->get_u2_fast();

   165           u1* utf8_buffer = cfs->get_u1_buffer();

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

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

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

   169           cfs->skip_u1_fast(utf8_length);

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

   171           if (_need_verify) {

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

   173           }

   174 

   175           unsigned int hash;

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

   177           if (result == NULL) {

   178             names[names_count] = (char*)utf8_buffer;

   179             lengths[names_count] = utf8_length;

   180             indices[names_count] = index;

   181             hashValues[names_count++] = hash;

   182             if (names_count == SymbolTable::symbol_alloc_batch_size) {

   183               oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);

   184               names_count = 0;

   185             }

   186           } else {

   187             cp->symbol_at_put(index, result);

   188           }

   189         }

   190         break;

   191       default:

   192         classfile_parse_error(

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

   194         break;

   195     }

   196   }

   197 

   198   // Allocate the remaining symbols

   199   if (names_count > 0) {

   200     oopFactory::new_symbols(cp, names_count, names, lengths, indices, hashValues, CHECK);

   201   }

   202 

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

   204 #ifdef ASSERT

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

   206 #endif

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

   208 }

   209 

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

   211 

   212 constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {

   213   ClassFileStream* cfs = stream();

   214   constantPoolHandle nullHandle;

   215 

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

   217   u2 length = cfs->get_u2_fast();

   218   guarantee_property(

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

   220     length, CHECK_(nullHandle));

   221   constantPoolOop constant_pool =

   222                       oopFactory::new_constantPool(length, CHECK_(nullHandle));

   223   constantPoolHandle cp (THREAD, constant_pool);

   224 

   225   cp->set_partially_loaded();    // Enables heap verify to work on partial constantPoolOops

   226 

   227   // parsing constant pool entries

   228   parse_constant_pool_entries(cp, length, CHECK_(nullHandle));

   229 

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

   231 

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

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

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

   235       case JVM_CONSTANT_Class :

   236         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present

   237         break;

   238       case JVM_CONSTANT_Fieldref :

   239         // fall through

   240       case JVM_CONSTANT_Methodref :

   241         // fall through

   242       case JVM_CONSTANT_InterfaceMethodref : {

   243         if (!_need_verify) break;

   244         int klass_ref_index = cp->klass_ref_index_at(index);

   245         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);

   246         check_property(valid_cp_range(klass_ref_index, length) &&

   247                        cp->tag_at(klass_ref_index).is_klass_reference(),

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

   249                        klass_ref_index,

   250                        CHECK_(nullHandle));

   251         check_property(valid_cp_range(name_and_type_ref_index, length) &&

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

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

   254                        name_and_type_ref_index,

   255                        CHECK_(nullHandle));

   256         break;

   257       }

   258       case JVM_CONSTANT_String :

   259         ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present

   260         break;

   261       case JVM_CONSTANT_Integer :

   262         break;

   263       case JVM_CONSTANT_Float :

   264         break;

   265       case JVM_CONSTANT_Long :

   266       case JVM_CONSTANT_Double :

   267         index++;

   268         check_property(

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

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

   271           index, CHECK_(nullHandle));

   272         break;

   273       case JVM_CONSTANT_NameAndType : {

   274         if (!_need_verify) break;

   275         int name_ref_index = cp->name_ref_index_at(index);

   276         int signature_ref_index = cp->signature_ref_index_at(index);

   277         check_property(

   278           valid_cp_range(name_ref_index, length) &&

   279             cp->tag_at(name_ref_index).is_utf8(),

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

   281           name_ref_index, CHECK_(nullHandle));

   282         check_property(

   283           valid_cp_range(signature_ref_index, length) &&

   284             cp->tag_at(signature_ref_index).is_utf8(),

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

   286           signature_ref_index, CHECK_(nullHandle));

   287         break;

   288       }

   289       case JVM_CONSTANT_Utf8 :

   290         break;

   291       case JVM_CONSTANT_UnresolvedClass :         // fall-through

   292       case JVM_CONSTANT_UnresolvedClassInError:

   293         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present

   294         break;

   295       case JVM_CONSTANT_ClassIndex :

   296         {

   297           int class_index = cp->klass_index_at(index);

   298           check_property(

   299             valid_cp_range(class_index, length) &&

   300               cp->tag_at(class_index).is_utf8(),

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

   302             class_index, CHECK_(nullHandle));

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

   304         }

   305         break;

   306       case JVM_CONSTANT_UnresolvedString :

   307         ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present

   308         break;

   309       case JVM_CONSTANT_StringIndex :

   310         {

   311           int string_index = cp->string_index_at(index);

   312           check_property(

   313             valid_cp_range(string_index, length) &&

   314               cp->tag_at(string_index).is_utf8(),

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

   316             string_index, CHECK_(nullHandle));

   317           symbolOop sym = cp->symbol_at(string_index);

   318           cp->unresolved_string_at_put(index, sym);

   319         }

   320         break;

   321       default:

   322         fatal1("bad constant pool tag value %u", cp->tag_at(index).value());

   323         ShouldNotReachHere();

   324         break;

   325     } // end of switch

   326   } // end of for

   327 

   328   if (!_need_verify) {

   329     return cp;

   330   }

   331 

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

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

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

   335     switch (tag) {

   336       case JVM_CONSTANT_UnresolvedClass: {

   337         symbolHandle class_name(THREAD, cp->unresolved_klass_at(index));

   338         verify_legal_class_name(class_name, CHECK_(nullHandle));

   339         break;

   340       }

   341       case JVM_CONSTANT_Fieldref:

   342       case JVM_CONSTANT_Methodref:

   343       case JVM_CONSTANT_InterfaceMethodref: {

   344         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);

   345         // already verified to be utf8

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

   347         // already verified to be utf8

   348         int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);

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

   350         symbolHandle signature(THREAD, cp->symbol_at(signature_ref_index));

   351         if (tag == JVM_CONSTANT_Fieldref) {

   352           verify_legal_field_name(name, CHECK_(nullHandle));

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

   354         } else {

   355           verify_legal_method_name(name, CHECK_(nullHandle));

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

   357           if (tag == JVM_CONSTANT_Methodref) {

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

   359             assert(!name.is_null(), "method name in constant pool is null");

   360             unsigned int name_len = name->utf8_length();

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

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

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

   364                 classfile_parse_error(

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

   366                   name_ref_index, CHECK_(nullHandle));

   367               }

   368             }

   369           }

   370         }

   371         break;

   372       }

   373     }  // end of switch

   374   }  // end of for

   375 

   376   return cp;

   377 }

   378 

   379 

   380 class NameSigHash: public ResourceObj {

   381  public:

   382   symbolOop     _name;       // name

   383   symbolOop     _sig;        // signature

   384   NameSigHash*  _next;       // Next entry in hash table

   385 };

   386 

   387 

   388 #define HASH_ROW_SIZE 256

   389 

   390 unsigned int hash(symbolOop name, symbolOop sig) {

   391   unsigned int raw_hash = 0;

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

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

   394 

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

   396 }

   397 

   398 

   399 void initialize_hashtable(NameSigHash** table) {

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

   401 }

   402 

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

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

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

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

   407 // of table since we don't expect symbolOop's to move.

   408 bool put_after_lookup(symbolOop name, symbolOop sig, NameSigHash** table) {

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

   410 

   411   // First lookup for duplicates

   412   int index = hash(name, sig);

   413   NameSigHash* entry = table[index];

   414   while (entry != NULL) {

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

   416       return false;

   417     }

   418     entry = entry->_next;

   419   }

   420 

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

   422   entry = new NameSigHash();

   423   entry->_name = name;

   424   entry->_sig = sig;

   425 

   426   // Insert into hash table

   427   entry->_next = table[index];

   428   table[index] = entry;

   429 

   430   return true;

   431 }

   432 

   433 

   434 objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,

   435                                                  int length,

   436                                                  Handle class_loader,

   437                                                  Handle protection_domain,

   438                                                  PerfTraceTime* vmtimer,

   439                                                  symbolHandle class_name,

   440                                                  TRAPS) {

   441   ClassFileStream* cfs = stream();

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

   443   objArrayHandle nullHandle;

   444   objArrayOop interface_oop = oopFactory::new_system_objArray(length, CHECK_(nullHandle));

   445   objArrayHandle interfaces (THREAD, interface_oop);

   446 

   447   int index;

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

   449     u2 interface_index = cfs->get_u2(CHECK_(nullHandle));

   450     check_property(

   451       valid_cp_range(interface_index, cp->length()) &&

   452         cp->tag_at(interface_index).is_unresolved_klass(),

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

   454       interface_index, CHECK_(nullHandle));

   455     symbolHandle unresolved_klass (THREAD, cp->klass_name_at(interface_index));

   456 

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

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

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

   460                        "Bad interface name in class file %s", CHECK_(nullHandle));

   461 

   462     vmtimer->suspend();  // do not count recursive loading twice

   463     // Call resolve_super so classcircularity is checked

   464     klassOop k = SystemDictionary::resolve_super_or_fail(class_name,

   465                   unresolved_klass, class_loader, protection_domain,

   466                   false, CHECK_(nullHandle));

   467     KlassHandle interf (THREAD, k);

   468     vmtimer->resume();

   469 

   470     if (!Klass::cast(interf())->is_interface()) {

   471       THROW_MSG_(vmSymbols::java_lang_IncompatibleClassChangeError(), "Implementing class", nullHandle);

   472     }

   473     interfaces->obj_at_put(index, interf());

   474   }

   475 

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

   477     return interfaces;

   478   }

   479 

   480   // Check if there's any duplicates in interfaces

   481   ResourceMark rm(THREAD);

   482   NameSigHash** interface_names = NEW_RESOURCE_ARRAY_IN_THREAD(

   483     THREAD, NameSigHash*, HASH_ROW_SIZE);

   484   initialize_hashtable(interface_names);

   485   bool dup = false;

   486   {

   487     debug_only(No_Safepoint_Verifier nsv;)

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

   489       klassOop k = (klassOop)interfaces->obj_at(index);

   490       symbolOop name = instanceKlass::cast(k)->name();

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

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

   493         dup = true;

   494         break;

   495       }

   496     }

   497   }

   498   if (dup) {

   499     classfile_parse_error("Duplicate interface name in class file %s",

   500                           CHECK_(nullHandle));

   501   }

   502 

   503   return interfaces;

   504 }

   505 

   506 

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

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

   509   guarantee_property(

   510     (constantvalue_index > 0 &&

   511       constantvalue_index < cp->length()),

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

   513     constantvalue_index, CHECK);

   514   constantTag value_type = cp->tag_at(constantvalue_index);

   515   switch ( cp->basic_type_for_signature_at(signature_index) ) {

   516     case T_LONG:

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

   518       break;

   519     case T_FLOAT:

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

   521       break;

   522     case T_DOUBLE:

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

   524       break;

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

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

   527       break;

   528     case T_OBJECT:

   529       guarantee_property((cp->symbol_at(signature_index)->equals("Ljava/lang/String;", 18)

   530                          && (value_type.is_string() || value_type.is_unresolved_string())),

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

   532       break;

   533     default:

   534       classfile_parse_error(

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

   536         constantvalue_index, CHECK);

   537   }

   538 }

   539 

   540 

   541 // Parse attributes for a field.

   542 void ClassFileParser::parse_field_attributes(constantPoolHandle cp,

   543                                              u2 attributes_count,

   544                                              bool is_static, u2 signature_index,

   545                                              u2* constantvalue_index_addr,

   546                                              bool* is_synthetic_addr,

   547                                              u2* generic_signature_index_addr,

   548                                              typeArrayHandle* field_annotations,

   549                                              TRAPS) {

   550   ClassFileStream* cfs = stream();

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

   552   u2 constantvalue_index = 0;

   553   u2 generic_signature_index = 0;

   554   bool is_synthetic = false;

   555   u1* runtime_visible_annotations = NULL;

   556   int runtime_visible_annotations_length = 0;

   557   u1* runtime_invisible_annotations = NULL;

   558   int runtime_invisible_annotations_length = 0;

   559   while (attributes_count--) {

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

   561     u2 attribute_name_index = cfs->get_u2_fast();

   562     u4 attribute_length = cfs->get_u4_fast();

   563     check_property(valid_cp_range(attribute_name_index, cp->length()) &&

   564                    cp->tag_at(attribute_name_index).is_utf8(),

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

   566                    attribute_name_index,

   567                    CHECK);

   568     symbolOop attribute_name = cp->symbol_at(attribute_name_index);

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

   570       // ignore if non-static

   571       if (constantvalue_index != 0) {

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

   573       }

   574       check_property(

   575         attribute_length == 2,

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

   577         attribute_length, CHECK);

   578       constantvalue_index = cfs->get_u2(CHECK);

   579       if (_need_verify) {

   580         verify_constantvalue(constantvalue_index, signature_index, cp, CHECK);

   581       }

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

   583       if (attribute_length != 0) {

   584         classfile_parse_error(

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

   586           attribute_length, CHECK);

   587       }

   588       is_synthetic = true;

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

   590       if (attribute_length != 0) {

   591         classfile_parse_error(

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

   593           attribute_length, CHECK);

   594       }

   595     } else if (_major_version >= JAVA_1_5_VERSION) {

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

   597         if (attribute_length != 2) {

   598           classfile_parse_error(

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

   600             attribute_length, CHECK);

   601         }

   602         generic_signature_index = cfs->get_u2(CHECK);

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

   604         runtime_visible_annotations_length = attribute_length;

   605         runtime_visible_annotations = cfs->get_u1_buffer();

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

   607         cfs->skip_u1(runtime_visible_annotations_length, CHECK);

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

   609         runtime_invisible_annotations_length = attribute_length;

   610         runtime_invisible_annotations = cfs->get_u1_buffer();

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

   612         cfs->skip_u1(runtime_invisible_annotations_length, CHECK);

   613       } else {

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

   615       }

   616     } else {

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

   618     }

   619   }

   620 

   621   *constantvalue_index_addr = constantvalue_index;

   622   *is_synthetic_addr = is_synthetic;

   623   *generic_signature_index_addr = generic_signature_index;

   624   *field_annotations = assemble_annotations(runtime_visible_annotations,

   625                                             runtime_visible_annotations_length,

   626                                             runtime_invisible_annotations,

   627                                             runtime_invisible_annotations_length,

   628                                             CHECK);

   629   return;

   630 }

   631 

   632 

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

   634 

   635 enum FieldAllocationType {

   636   STATIC_OOP,           // Oops

   637   STATIC_BYTE,          // Boolean, Byte, char

   638   STATIC_SHORT,         // shorts

   639   STATIC_WORD,          // ints

   640   STATIC_DOUBLE,        // long or double

   641   STATIC_ALIGNED_DOUBLE,// aligned long or double

   642   NONSTATIC_OOP,

   643   NONSTATIC_BYTE,

   644   NONSTATIC_SHORT,

   645   NONSTATIC_WORD,

   646   NONSTATIC_DOUBLE,

   647   NONSTATIC_ALIGNED_DOUBLE

   648 };

   649 

   650 

   651 struct FieldAllocationCount {

   652   int static_oop_count;

   653   int static_byte_count;

   654   int static_short_count;

   655   int static_word_count;

   656   int static_double_count;

   657   int nonstatic_oop_count;

   658   int nonstatic_byte_count;

   659   int nonstatic_short_count;

   660   int nonstatic_word_count;

   661   int nonstatic_double_count;

   662 };

   663 

   664 typeArrayHandle ClassFileParser::parse_fields(constantPoolHandle cp, bool is_interface,

   665                                               struct FieldAllocationCount *fac,

   666                                               objArrayHandle* fields_annotations, TRAPS) {

   667   ClassFileStream* cfs = stream();

   668   typeArrayHandle nullHandle;

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

   670   u2 length = cfs->get_u2_fast();

   671   // Tuples of shorts [access, name index, sig index, initial value index, byte offset, generic signature index]

   672   typeArrayOop new_fields = oopFactory::new_permanent_shortArray(length*instanceKlass::next_offset, CHECK_(nullHandle));

   673   typeArrayHandle fields(THREAD, new_fields);

   674 

   675   int index = 0;

   676   typeArrayHandle field_annotations;

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

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

   679 

   680     AccessFlags access_flags;

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

   682     verify_legal_field_modifiers(flags, is_interface, CHECK_(nullHandle));

   683     access_flags.set_flags(flags);

   684 

   685     u2 name_index = cfs->get_u2_fast();

   686     int cp_size = cp->length();

   687     check_property(

   688       valid_cp_range(name_index, cp_size) && cp->tag_at(name_index).is_utf8(),

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

   690       name_index, CHECK_(nullHandle));

   691     symbolHandle name(THREAD, cp->symbol_at(name_index));

   692     verify_legal_field_name(name, CHECK_(nullHandle));

   693 

   694     u2 signature_index = cfs->get_u2_fast();

   695     check_property(

   696       valid_cp_range(signature_index, cp_size) &&

   697         cp->tag_at(signature_index).is_utf8(),

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

   699       signature_index, CHECK_(nullHandle));

   700     symbolHandle sig(THREAD, cp->symbol_at(signature_index));

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

   702 

   703     u2 constantvalue_index = 0;

   704     bool is_synthetic = false;

   705     u2 generic_signature_index = 0;

   706     bool is_static = access_flags.is_static();

   707 

   708     u2 attributes_count = cfs->get_u2_fast();

   709     if (attributes_count > 0) {

   710       parse_field_attributes(cp, attributes_count, is_static, signature_index,

   711                              &constantvalue_index, &is_synthetic,

   712                              &generic_signature_index, &field_annotations,

   713                              CHECK_(nullHandle));

   714       if (field_annotations.not_null()) {

   715         if (fields_annotations->is_null()) {

   716           objArrayOop md = oopFactory::new_system_objArray(length, CHECK_(nullHandle));

   717           *fields_annotations = objArrayHandle(THREAD, md);

   718         }

   719         (*fields_annotations)->obj_at_put(n, field_annotations());

   720       }

   721       if (is_synthetic) {

   722         access_flags.set_is_synthetic();

   723       }

   724     }

   725 

   726     fields->short_at_put(index++, access_flags.as_short());

   727     fields->short_at_put(index++, name_index);

   728     fields->short_at_put(index++, signature_index);

   729     fields->short_at_put(index++, constantvalue_index);

   730 

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

   732     BasicType type = cp->basic_type_for_signature_at(signature_index);

   733     FieldAllocationType atype;

   734     if ( is_static ) {

   735       switch ( type ) {

   736         case  T_BOOLEAN:

   737         case  T_BYTE:

   738           fac->static_byte_count++;

   739           atype = STATIC_BYTE;

   740           break;

   741         case  T_LONG:

   742         case  T_DOUBLE:

   743           if (Universe::field_type_should_be_aligned(type)) {

   744             atype = STATIC_ALIGNED_DOUBLE;

   745           } else {

   746             atype = STATIC_DOUBLE;

   747           }

   748           fac->static_double_count++;

   749           break;

   750         case  T_CHAR:

   751         case  T_SHORT:

   752           fac->static_short_count++;

   753           atype = STATIC_SHORT;

   754           break;

   755         case  T_FLOAT:

   756         case  T_INT:

   757           fac->static_word_count++;

   758           atype = STATIC_WORD;

   759           break;

   760         case  T_ARRAY:

   761         case  T_OBJECT:

   762           fac->static_oop_count++;

   763           atype = STATIC_OOP;

   764           break;

   765         case  T_ADDRESS:

   766         case  T_VOID:

   767         default:

   768           assert(0, "bad field type");

   769       }

   770     } else {

   771       switch ( type ) {

   772         case  T_BOOLEAN:

   773         case  T_BYTE:

   774           fac->nonstatic_byte_count++;

   775           atype = NONSTATIC_BYTE;

   776           break;

   777         case  T_LONG:

   778         case  T_DOUBLE:

   779           if (Universe::field_type_should_be_aligned(type)) {

   780             atype = NONSTATIC_ALIGNED_DOUBLE;

   781           } else {

   782             atype = NONSTATIC_DOUBLE;

   783           }

   784           fac->nonstatic_double_count++;

   785           break;

   786         case  T_CHAR:

   787         case  T_SHORT:

   788           fac->nonstatic_short_count++;

   789           atype = NONSTATIC_SHORT;

   790           break;

   791         case  T_FLOAT:

   792         case  T_INT:

   793           fac->nonstatic_word_count++;

   794           atype = NONSTATIC_WORD;

   795           break;

   796         case  T_ARRAY:

   797         case  T_OBJECT:

   798           fac->nonstatic_oop_count++;

   799           atype = NONSTATIC_OOP;

   800           break;

   801         case  T_ADDRESS:

   802         case  T_VOID:

   803         default:

   804           assert(0, "bad field type");

   805       }

   806     }

   807 

   808     // The correct offset is computed later (all oop fields will be located together)

   809     // We temporarily store the allocation type in the offset field

   810     fields->short_at_put(index++, atype);

   811     fields->short_at_put(index++, 0);  // Clear out high word of byte offset

   812     fields->short_at_put(index++, generic_signature_index);

   813   }

   814 

   815   if (_need_verify && length > 1) {

   816     // Check duplicated fields

   817     ResourceMark rm(THREAD);

   818     NameSigHash** names_and_sigs = NEW_RESOURCE_ARRAY_IN_THREAD(

   819       THREAD, NameSigHash*, HASH_ROW_SIZE);

   820     initialize_hashtable(names_and_sigs);

   821     bool dup = false;

   822     {

   823       debug_only(No_Safepoint_Verifier nsv;)

   824       for (int i = 0; i < length*instanceKlass::next_offset; i += instanceKlass::next_offset) {

   825         int name_index = fields->ushort_at(i + instanceKlass::name_index_offset);

   826         symbolOop name = cp->symbol_at(name_index);

   827         int sig_index = fields->ushort_at(i + instanceKlass::signature_index_offset);

   828         symbolOop sig = cp->symbol_at(sig_index);

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

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

   831           dup = true;

   832           break;

   833         }

   834       }

   835     }

   836     if (dup) {

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

   838                             CHECK_(nullHandle));

   839     }

   840   }

   841 

   842   return fields;

   843 }

   844 

   845 

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

   847   while (length-- > 0) {

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

   849   }

   850 }

   851 

   852 

   853 typeArrayHandle ClassFileParser::parse_exception_table(u4 code_length,

   854                                                        u4 exception_table_length,

   855                                                        constantPoolHandle cp,

   856                                                        TRAPS) {

   857   ClassFileStream* cfs = stream();

   858   typeArrayHandle nullHandle;

   859 

   860   // 4-tuples of ints [start_pc, end_pc, handler_pc, catch_type index]

   861   typeArrayOop eh = oopFactory::new_permanent_intArray(exception_table_length*4, CHECK_(nullHandle));

   862   typeArrayHandle exception_handlers = typeArrayHandle(THREAD, eh);

   863 

   864   int index = 0;

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

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

   867     u2 start_pc = cfs->get_u2_fast();

   868     u2 end_pc = cfs->get_u2_fast();

   869     u2 handler_pc = cfs->get_u2_fast();

   870     u2 catch_type_index = cfs->get_u2_fast();

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

   872     if (_need_verify) {

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

   874                          "Illegal exception table range in class file %s", CHECK_(nullHandle));

   875       guarantee_property(handler_pc < code_length,

   876                          "Illegal exception table handler in class file %s", CHECK_(nullHandle));

   877       if (catch_type_index != 0) {

   878         guarantee_property(valid_cp_range(catch_type_index, cp->length()) &&

   879                           (cp->tag_at(catch_type_index).is_klass() ||

   880                            cp->tag_at(catch_type_index).is_unresolved_klass()),

   881                            "Catch type in exception table has bad constant type in class file %s", CHECK_(nullHandle));

   882       }

   883     }

   884     exception_handlers->int_at_put(index++, start_pc);

   885     exception_handlers->int_at_put(index++, end_pc);

   886     exception_handlers->int_at_put(index++, handler_pc);

   887     exception_handlers->int_at_put(index++, catch_type_index);

   888   }

   889   return exception_handlers;

   890 }

   891 

   892 void ClassFileParser::parse_linenumber_table(

   893     u4 code_attribute_length, u4 code_length,

   894     CompressedLineNumberWriteStream** write_stream, TRAPS) {

   895   ClassFileStream* cfs = stream();

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

   897 

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

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

   900 

   901   // Verify line number attribute and table length

   902   check_property(

   903     code_attribute_length == sizeof(u2) + length_in_bytes,

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

   905 

   906   cfs->guarantee_more(length_in_bytes, CHECK);

   907 

   908   if ((*write_stream) == NULL) {

   909     if (length_in_bytes > fixed_buffer_size) {

   910       (*write_stream) = new CompressedLineNumberWriteStream(length_in_bytes);

   911     } else {

   912       (*write_stream) = new CompressedLineNumberWriteStream(

   913         linenumbertable_buffer, fixed_buffer_size);

   914     }

   915   }

   916 

   917   while (num_entries-- > 0) {

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

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

   920     guarantee_property(bci < code_length,

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

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

   923   }

   924 }

   925 

   926 

   927 // Class file LocalVariableTable elements.

   928 class Classfile_LVT_Element VALUE_OBJ_CLASS_SPEC {

   929  public:

   930   u2 start_bci;

   931   u2 length;

   932   u2 name_cp_index;

   933   u2 descriptor_cp_index;

   934   u2 slot;

   935 };

   936 

   937 

   938 class LVT_Hash: public CHeapObj {

   939  public:

   940   LocalVariableTableElement  *_elem;  // element

   941   LVT_Hash*                   _next;  // Next entry in hash table

   942 };

   943 

   944 unsigned int hash(LocalVariableTableElement *elem) {

   945   unsigned int raw_hash = elem->start_bci;

   946 

   947   raw_hash = elem->length        + raw_hash * 37;

   948   raw_hash = elem->name_cp_index + raw_hash * 37;

   949   raw_hash = elem->slot          + raw_hash * 37;

   950 

   951   return raw_hash % HASH_ROW_SIZE;

   952 }

   953 

   954 void initialize_hashtable(LVT_Hash** table) {

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

   956     table[i] = NULL;

   957   }

   958 }

   959 

   960 void clear_hashtable(LVT_Hash** table) {

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

   962     LVT_Hash* current = table[i];

   963     LVT_Hash* next;

   964     while (current != NULL) {

   965       next = current->_next;

   966       current->_next = NULL;

   967       delete(current);

   968       current = next;

   969     }

   970     table[i] = NULL;

   971   }

   972 }

   973 

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

   975   LVT_Hash* entry = table[index];

   976 

   977   /*

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

   979    * so the following comparison seems to be redundant:

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

   981    */

   982   while (entry != NULL) {

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

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

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

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

   987     ) {

   988       return entry;

   989     }

   990     entry = entry->_next;

   991   }

   992   return NULL;

   993 }

   994 

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

   996 // Return true if no duplicate is found.

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

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

   999   // First lookup for duplicates

  1000   int index = hash(elem);

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

  1002 

  1003   if (entry != NULL) {

  1004       return false;

  1005   }

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

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

  1008     return false;

  1009   }

  1010   entry->_elem = elem;

  1011 

  1012   // Insert into hash table

  1013   entry->_next = table[index];

  1014   table[index] = entry;

  1015 

  1016   return true;

  1017 }

  1018 

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

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

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

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

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

  1024   lvt->signature_cp_index  = 0;

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

  1026 }

  1027 

  1028 // Function is used to parse both attributes:

  1029 //       LocalVariableTable (LVT) and LocalVariableTypeTable (LVTT)

  1030 u2* ClassFileParser::parse_localvariable_table(u4 code_length,

  1031                                                u2 max_locals,

  1032                                                u4 code_attribute_length,

  1033                                                constantPoolHandle cp,

  1034                                                u2* localvariable_table_length,

  1035                                                bool isLVTT,

  1036                                                TRAPS) {

  1037   ClassFileStream* cfs = stream();

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

  1039   *localvariable_table_length = cfs->get_u2(CHECK_NULL);

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

  1041   // Verify local variable table attribute has right length

  1042   if (_need_verify) {

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

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

  1045   }

  1046   u2* localvariable_table_start = cfs->get_u2_buffer();

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

  1048   if (!_need_verify) {

  1049     cfs->skip_u2_fast(size);

  1050   } else {

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

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

  1053       u2 start_pc = cfs->get_u2_fast();

  1054       u2 length = cfs->get_u2_fast();

  1055       u2 name_index = cfs->get_u2_fast();

  1056       u2 descriptor_index = cfs->get_u2_fast();

  1057       u2 index = cfs->get_u2_fast();

  1058       // Assign to a u4 to avoid overflow

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

  1060 

  1061       if (start_pc >= code_length) {

  1062         classfile_parse_error(

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

  1064           start_pc, tbl_name, CHECK_NULL);

  1065       }

  1066       if (end_pc > code_length) {

  1067         classfile_parse_error(

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

  1069           length, tbl_name, CHECK_NULL);

  1070       }

  1071       int cp_size = cp->length();

  1072       guarantee_property(

  1073         valid_cp_range(name_index, cp_size) &&

  1074           cp->tag_at(name_index).is_utf8(),

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

  1076         name_index, tbl_name, CHECK_NULL);

  1077       guarantee_property(

  1078         valid_cp_range(descriptor_index, cp_size) &&

  1079           cp->tag_at(descriptor_index).is_utf8(),

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

  1081         descriptor_index, tbl_name, CHECK_NULL);

  1082 

  1083       symbolHandle name(THREAD, cp->symbol_at(name_index));

  1084       symbolHandle sig(THREAD, cp->symbol_at(descriptor_index));

  1085       verify_legal_field_name(name, CHECK_NULL);

  1086       u2 extra_slot = 0;

  1087       if (!isLVTT) {

  1088         verify_legal_field_signature(name, sig, CHECK_NULL);

  1089 

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

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

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

  1093           extra_slot = 1;

  1094         }

  1095       }

  1096       guarantee_property((index + extra_slot) < max_locals,

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

  1098                           index, tbl_name, CHECK_NULL);

  1099     }

  1100   }

  1101   return localvariable_table_start;

  1102 }

  1103 

  1104 

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

  1106                                       u1* u1_array, u2* u2_array, constantPoolHandle cp, TRAPS) {

  1107   ClassFileStream* cfs = stream();

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

  1109   u4 i1 = *u1_index;

  1110   u4 i2 = *u2_index + 1;

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

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

  1113     index++;

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

  1115       index++;

  1116     } else if (tag == ITEM_Object) {

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

  1118       guarantee_property(valid_cp_range(class_index, cp->length()) &&

  1119                          cp->tag_at(class_index).is_unresolved_klass(),

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

  1121                          class_index, CHECK);

  1122     } else if (tag == ITEM_Uninitialized) {

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

  1124       guarantee_property(

  1125         offset < code_length,

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

  1127         offset, CHECK);

  1128     } else {

  1129       guarantee_property(

  1130         tag <= (u1)ITEM_Uninitialized,

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

  1132         tag, CHECK);

  1133     }

  1134   }

  1135   u2_array[*u2_index] = index;