#include "interpreter/interpreter.hpp"

#include "memory/gcLocker.hpp"

#include "memory/metadataFactory.hpp"

#include "oops/constMethod.hpp"

#include "oops/method.hpp"

const u2 ConstMethod::MAX_IDNUM   = 0xFFFE;

const u2 ConstMethod::UNSET_IDNUM = 0xFFFF;

ConstMethod* ConstMethod::allocate(ClassLoaderData* loader_data,

                                            int byte_code_size,

                                            int compressed_line_number_size,

                                            int localvariable_table_length,

                                            int exception_table_length,

                                            int checked_exceptions_length,

                                            TRAPS) {

  int size = ConstMethod::size(byte_code_size,

                                      compressed_line_number_size,

                                      localvariable_table_length,

                                      exception_table_length,

                                      checked_exceptions_length);

  return new (loader_data, size, true, THREAD) ConstMethod(

                       byte_code_size, compressed_line_number_size,

                       localvariable_table_length, exception_table_length,

                       checked_exceptions_length, size);

}

ConstMethod::ConstMethod(int byte_code_size,

                                       int compressed_line_number_size,

                                       int localvariable_table_length,

                                       int exception_table_length,

                                       int checked_exceptions_length,

                                       int size) {

  No_Safepoint_Verifier no_safepoint;

  set_interpreter_kind(Interpreter::invalid);

  init_fingerprint();

  set_constants(NULL);

  set_stackmap_data(NULL);

  set_code_size(byte_code_size);

  set_constMethod_size(size);

  set_inlined_tables_length(checked_exceptions_length,

                            compressed_line_number_size,

                            localvariable_table_length,

                            exception_table_length);

  assert(this->size() == size, "wrong size for object");

}

// Deallocate metadata fields associated with ConstMethod*

void ConstMethod::deallocate_contents(ClassLoaderData* loader_data) {

  set_interpreter_kind(Interpreter::invalid);

  if (stackmap_data() != NULL) {

    MetadataFactory::free_array<u1>(loader_data, stackmap_data());

  }

  set_stackmap_data(NULL);

}

int ConstMethod::size(int code_size,

Method* ConstMethod::method() const {

    return InstanceKlass::cast(_constants->pool_holder())->method_with_idnum(

u_char* ConstMethod::compressed_linenumber_table() const {

u2* ConstMethod::checked_exceptions_length_addr() const {

u2* ConstMethod::exception_table_length_addr() const {

u2* ConstMethod::localvariable_table_length_addr() const {

void ConstMethod::set_inlined_tables_length(

int ConstMethod::checked_exceptions_length() const {

CheckedExceptionElement* ConstMethod::checked_exceptions_start() const {

int ConstMethod::localvariable_table_length() const {

LocalVariableTableElement* ConstMethod::localvariable_table_start() const {

int ConstMethod::exception_table_length() const {

ExceptionTableElement* ConstMethod::exception_table_start() const {

// Printing

void ConstMethod::print_on(outputStream* st) const {

  ResourceMark rm;

  assert(is_constMethod(), "must be constMethod");

  st->print_cr(internal_name());

  st->print(" - method:       " INTPTR_FORMAT " ", (address)method());

  method()->print_value_on(st); st->cr();

  if (has_stackmap_table()) {

    st->print(" - stackmap data:       ");

    stackmap_data()->print_value_on(st);

    st->cr();

  }

}

// Short version of printing ConstMethod* - just print the name of the

// method it belongs to.

void ConstMethod::print_value_on(outputStream* st) const {

  assert(is_constMethod(), "must be constMethod");

  st->print(" const part of method " );

  method()->print_value_on(st);

}

// Verification

void ConstMethod::verify_on(outputStream* st) {

  guarantee(is_constMethod(), "object must be constMethod");

  guarantee(is_metadata(), err_msg("Should be metadata " PTR_FORMAT, this));

  // Verification can occur during oop construction before the method or

  // other fields have been initialized.

  guarantee(is_metadata(), err_msg("Should be metadata " PTR_FORMAT, this));

  guarantee(method()->is_method(), "should be method");

  address m_end = (address)((oop*) this + size());

  address compressed_table_start = code_end();

  guarantee(compressed_table_start <= m_end, "invalid method layout");

  address compressed_table_end = compressed_table_start;

  // Verify line number table

  if (has_linenumber_table()) {

    CompressedLineNumberReadStream stream(compressed_linenumber_table());

    while (stream.read_pair()) {

      guarantee(stream.bci() >= 0 && stream.bci() <= code_size(), "invalid bci in line number table");

    }

    compressed_table_end += stream.position();

  }

  guarantee(compressed_table_end <= m_end, "invalid method layout");

  // Verify checked exceptions, exception table and local variable tables

  if (has_checked_exceptions()) {

    u2* addr = checked_exceptions_length_addr();

    guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout");

  }

  if (has_exception_handler()) {

    u2* addr = exception_table_length_addr();

     guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout");

  }

  if (has_localvariable_table()) {

    u2* addr = localvariable_table_length_addr();

    guarantee(*addr > 0 && (address) addr >= compressed_table_end && (address) addr < m_end, "invalid method layout");

  }

  // Check compressed_table_end relative to uncompressed_table_start

  u2* uncompressed_table_start;

  if (has_localvariable_table()) {

    uncompressed_table_start = (u2*) localvariable_table_start();

  } else if (has_exception_handler()) {

    uncompressed_table_start = (u2*) exception_table_start();

  } else if (has_checked_exceptions()) {

      uncompressed_table_start = (u2*) checked_exceptions_start();

  } else {

      uncompressed_table_start = (u2*) m_end;

  }

  int gap = (intptr_t) uncompressed_table_start - (intptr_t) compressed_table_end;

  int max_gap = align_object_size(1)*BytesPerWord;

  guarantee(gap >= 0 && gap < max_gap, "invalid method layout");

}