/*

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

 *

 */

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

// Used for backward compatibility reasons:

// - to check NameAndType_info signatures more aggressively

#define JAVA_7_VERSION                    51

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

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

  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;

  // Side buffer for operands of variable-sized (InvokeDynamic) entries.

  GrowableArray<int>* operands = NULL;

#ifdef ASSERT

  GrowableArray<int>* indy_instructions = new GrowableArray<int>(THREAD, 10);

#endif

  // 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 (!EnableMethodHandles ||

            _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {

          classfile_parse_error(

            (!EnableMethodHandles ?

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

             "Class file version 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_InvokeDynamicTrans :  // this tag appears only in old classfiles

      case JVM_CONSTANT_InvokeDynamic :

        {

          if (!EnableInvokeDynamic ||

              _major_version < Verifier::INVOKEDYNAMIC_MAJOR_VERSION) {

            classfile_parse_error(

              (!EnableInvokeDynamic ?

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

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

              tag, CHECK);

          }

          if (!AllowTransitionalJSR292 && tag == JVM_CONSTANT_InvokeDynamicTrans) {

            classfile_parse_error(

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

                tag, CHECK);

          }

          bool trans_no_argc = AllowTransitionalJSR292 && (tag == JVM_CONSTANT_InvokeDynamicTrans);

          cfs->guarantee_more(7, CHECK);  // bsm_index, nt, argc, ..., tag/access_flags

          u2 bootstrap_method_index = cfs->get_u2_fast();

          u2 name_and_type_index = cfs->get_u2_fast();

          int argument_count = trans_no_argc ? 0 : cfs->get_u2_fast();

          cfs->guarantee_more(2*argument_count + 1, CHECK);  // argv[argc]..., tag/access_flags

          int argv_offset = constantPoolOopDesc::_indy_argv_offset;

          int op_count = argv_offset + argument_count;  // bsm, nt, argc, argv[]...

          int op_base = start_operand_group(operands, op_count, CHECK);

          assert(argv_offset == 3, "else adjust next 3 assignments");

          operands->at_put(op_base + constantPoolOopDesc::_indy_bsm_offset, bootstrap_method_index);

          operands->at_put(op_base + constantPoolOopDesc::_indy_nt_offset, name_and_type_index);

          operands->at_put(op_base + constantPoolOopDesc::_indy_argc_offset, argument_count);

          for (int arg_i = 0; arg_i < argument_count; arg_i++) {

            int arg = cfs->get_u2_fast();

            operands->at_put(op_base + constantPoolOopDesc::_indy_argv_offset + arg_i, arg);

          }

          cp->invoke_dynamic_at_put(index, op_base, op_count);

#ifdef ASSERT

          // Record the steps just taken for later checking.

          indy_instructions->append(index);

          indy_instructions->append(bootstrap_method_index);

          indy_instructions->append(name_and_type_index);

          indy_instructions->append(argument_count);

#endif //ASSERT

        }

        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 (AnonymousClasses && 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;

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

  }

  if (operands != NULL && operands->length() > 0) {

    store_operand_array(operands, cp, CHECK);

  }

#ifdef ASSERT

  // Re-assert the indy structures, now that assertion checking can work.

  for (int indy_i = 0; indy_i < indy_instructions->length(); ) {

    int index                  = indy_instructions->at(indy_i++);

    int bootstrap_method_index = indy_instructions->at(indy_i++);

    int name_and_type_index    = indy_instructions->at(indy_i++);

    int argument_count         = indy_instructions->at(indy_i++);

    assert(cp->check_invoke_dynamic_at(index,

                                       bootstrap_method_index, name_and_type_index,

                                       argument_count),

           "indy structure is OK");

  }

#endif //ASSERT

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

}

int ClassFileParser::start_operand_group(GrowableArray<int>* &operands, int op_count, TRAPS) {

  if (operands == NULL) {

    operands = new GrowableArray<int>(THREAD, 100);

    int fillp_offset = constantPoolOopDesc::_multi_operand_buffer_fill_pointer_offset;

    while (operands->length() <= fillp_offset)

      operands->append(0);  // force op_base > 0, for an error check

    DEBUG_ONLY(operands->at_put(fillp_offset, (int)badHeapWordVal));

  }

  int cnt_pos = operands->append(op_count);

  int arg_pos = operands->length();

  operands->at_grow(arg_pos + op_count - 1);  // grow to include the operands

  assert(operands->length() == arg_pos + op_count, "");

  int op_base = cnt_pos - constantPoolOopDesc::_multi_operand_count_offset;

  return op_base;

}

void ClassFileParser::store_operand_array(GrowableArray<int>* operands, constantPoolHandle cp, TRAPS) {

  // Collect the buffer of operands from variable-sized entries into a permanent array.

  int arraylen = operands->length();

  int fillp_offset = constantPoolOopDesc::_multi_operand_buffer_fill_pointer_offset;

  assert(operands->at(fillp_offset) == (int)badHeapWordVal, "value unused so far");

  operands->at_put(fillp_offset, arraylen);

  cp->multi_operand_buffer_grow(arraylen, CHECK);

  typeArrayOop operands_oop = cp->operands();

  assert(operands_oop->length() == arraylen, "");

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

    operands_oop->int_at_put(i, operands->at(i));

  }

  cp->set_operands(operands_oop);

  // The fill_pointer is used only by constantPoolOop::copy_entry_to and friends,

  // when constant pools need to be merged.  Make sure it is sane now.

  assert(cp->multi_operand_buffer_fill_pointer() == arraylen, "");

}

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,

                                                   methodOopDesc::IsSafeConc,

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

                       is_klass_reference(cp, 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_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;

      case JVM_CONSTANT_MethodHandle :

        {

          int ref_index = cp->method_handle_index_at(index);

          check_property(

            valid_cp_range(ref_index, length) &&

                EnableMethodHandles,

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