/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

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

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_classFileParser.cpp.incl"

// 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        51

#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

void ClassFileParser::parse_constant_pool_entries(constantPoolHandle cp, 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

  u1* old_current = cfs0->current();

#endif

  // 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_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);

          }

          unsigned int hash;

          symbolOop 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) {

              oopFactory::new_symbols(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) {

    oopFactory::new_symbols(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); }

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));

  constantPoolOop constant_pool =

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

  constantPoolHandle cp (THREAD, constant_pool);

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

  // parsing constant pool entries

  parse_constant_pool_entries(cp, 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

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

      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_cp_range(klass_ref_index, length) &&

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

                       "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_cp_range(name_ref_index, length) &&

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

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

          name_ref_index, CHECK_(nullHandle));

        check_property(

          valid_cp_range(signature_ref_index, length) &&

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

          "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_cp_range(class_index, length) &&

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

            "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_UnresolvedString :

        ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present

        break;

      case JVM_CONSTANT_StringIndex :

        {

          int string_index = cp->string_index_at(index);

          check_property(

            valid_cp_range(string_index, length) &&

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

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

            string_index, CHECK_(nullHandle));

          symbolOop sym = cp->symbol_at(string_index);

          cp->unresolved_string_at_put(index, sym);

        }

        break;

      default:

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

        ShouldNotReachHere();

        break;

    } // end of switch

  } // end of for

  if (!_need_verify) {

    return cp;

  }

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

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

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

    switch (tag) {

      case JVM_CONSTANT_UnresolvedClass: {

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

        verify_legal_class_name(class_name, CHECK_(nullHandle));

        break;

      }

      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);

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

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

        if (tag == JVM_CONSTANT_Fieldref) {

          verify_legal_field_name(name, CHECK_(nullHandle));

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

        } else {

          verify_legal_method_name(name, CHECK_(nullHandle));

          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.is_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;

      }

    }  // end of switch

  }  // end of for

  return cp;

}

class NameSigHash: public ResourceObj {

 public:

  symbolOop     _name;       // name

  symbolOop     _sig;        // signature

  NameSigHash*  _next;       // Next entry in hash table

};

#define HASH_ROW_SIZE 256

unsigned int hash(symbolOop name, symbolOop 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 symbolOop's to move.

bool put_after_lookup(symbolOop name, symbolOop 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;

}

objArrayHandle ClassFileParser::parse_interfaces(constantPoolHandle cp,

                                                 int length,

                                                 Handle class_loader,

                                                 Handle protection_domain,

                                                 PerfTraceTime* vmtimer,

                                                 symbolHandle class_name,

                                                 TRAPS) {

  ClassFileStream* cfs = stream();

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

  objArrayHandle nullHandle;

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

  objArrayHandle interfaces (THREAD, interface_oop);

  int index;

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

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

    check_property(

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

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

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

      interface_index, CHECK_(nullHandle));

    symbolHandle unresolved_klass (THREAD, 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_(nullHandle));

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

    // Call resolve_super so classcircularity is checked

    klassOop k = SystemDictionary::resolve_super_or_fail(class_name,

                  unresolved_klass, class_loader, protection_domain,

                  false, CHECK_(nullHandle));

    KlassHandle interf (THREAD, k);

    vmtimer->resume();

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

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

    }

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

  }

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

    return 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++) {

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

      symbolOop 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_(nullHandle));

  }

  return interfaces;

}

void ClassFileParser::verify_constantvalue(int constantvalue_index, int signature_index, constantPoolHandle cp, 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;