/*

 * Copyright 1997-2008 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/_nmethod.cpp.incl"

#ifdef DTRACE_ENABLED

// Only bother with this argument setup if dtrace is available

HS_DTRACE_PROBE_DECL8(hotspot, compiled__method__load,

  const char*, int, const char*, int, const char*, int, void*, size_t);

HS_DTRACE_PROBE_DECL6(hotspot, compiled__method__unload,

  char*, int, char*, int, char*, int);

#define DTRACE_METHOD_UNLOAD_PROBE(method)                                \

  {                                                                       \

    methodOop m = (method);                                               \

    if (m != NULL) {                                                      \

      symbolOop klass_name = m->klass_name();                             \

      symbolOop name = m->name();                                         \

      symbolOop signature = m->signature();                               \

      HS_DTRACE_PROBE6(hotspot, compiled__method__unload,                 \

        klass_name->bytes(), klass_name->utf8_length(),                   \

        name->bytes(), name->utf8_length(),                               \

        signature->bytes(), signature->utf8_length());                    \

    }                                                                     \

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_METHOD_UNLOAD_PROBE(method)

#endif

bool nmethod::is_compiled_by_c1() const {

  if (is_native_method()) return false;

  assert(compiler() != NULL, "must be");

  return compiler()->is_c1();

}

bool nmethod::is_compiled_by_c2() const {

  if (is_native_method()) return false;

  assert(compiler() != NULL, "must be");

  return compiler()->is_c2();

}

//---------------------------------------------------------------------------------

// NMethod statistics

// They are printed under various flags, including:

//   PrintC1Statistics, PrintOptoStatistics, LogVMOutput, and LogCompilation.

// (In the latter two cases, they like other stats are printed to the log only.)

#ifndef PRODUCT

// These variables are put into one block to reduce relocations

// and make it simpler to print from the debugger.

static

struct nmethod_stats_struct {

  int nmethod_count;

  int total_size;

  int relocation_size;

  int code_size;

  int stub_size;

  int consts_size;

  int scopes_data_size;

  int scopes_pcs_size;

  int dependencies_size;

  int handler_table_size;

  int nul_chk_table_size;

  int oops_size;

  void note_nmethod(nmethod* nm) {

    nmethod_count += 1;

    total_size          += nm->size();

    relocation_size     += nm->relocation_size();

    code_size           += nm->code_size();

    stub_size           += nm->stub_size();

    consts_size         += nm->consts_size();

    scopes_data_size    += nm->scopes_data_size();

    scopes_pcs_size     += nm->scopes_pcs_size();

    dependencies_size   += nm->dependencies_size();

    handler_table_size  += nm->handler_table_size();

    nul_chk_table_size  += nm->nul_chk_table_size();

    oops_size += nm->oops_size();

  }

  void print_nmethod_stats() {

    if (nmethod_count == 0)  return;

    tty->print_cr("Statistics for %d bytecoded nmethods:", nmethod_count);

    if (total_size != 0)          tty->print_cr(" total in heap  = %d", total_size);

    if (relocation_size != 0)     tty->print_cr(" relocation     = %d", relocation_size);

    if (code_size != 0)           tty->print_cr(" main code      = %d", code_size);

    if (stub_size != 0)           tty->print_cr(" stub code      = %d", stub_size);

    if (consts_size != 0)         tty->print_cr(" constants      = %d", consts_size);

    if (scopes_data_size != 0)    tty->print_cr(" scopes data    = %d", scopes_data_size);

    if (scopes_pcs_size != 0)     tty->print_cr(" scopes pcs     = %d", scopes_pcs_size);

    if (dependencies_size != 0)   tty->print_cr(" dependencies   = %d", dependencies_size);

    if (handler_table_size != 0)  tty->print_cr(" handler table  = %d", handler_table_size);

    if (nul_chk_table_size != 0)  tty->print_cr(" nul chk table  = %d", nul_chk_table_size);

    if (oops_size != 0)           tty->print_cr(" oops           = %d", oops_size);

  }

  int native_nmethod_count;

  int native_total_size;

  int native_relocation_size;

  int native_code_size;

  int native_oops_size;

  void note_native_nmethod(nmethod* nm) {

    native_nmethod_count += 1;

    native_total_size       += nm->size();

    native_relocation_size  += nm->relocation_size();

    native_code_size        += nm->code_size();

    native_oops_size        += nm->oops_size();

  }

  void print_native_nmethod_stats() {

    if (native_nmethod_count == 0)  return;

    tty->print_cr("Statistics for %d native nmethods:", native_nmethod_count);

    if (native_total_size != 0)       tty->print_cr(" N. total size  = %d", native_total_size);

    if (native_relocation_size != 0)  tty->print_cr(" N. relocation  = %d", native_relocation_size);

    if (native_code_size != 0)        tty->print_cr(" N. main code   = %d", native_code_size);

    if (native_oops_size != 0)        tty->print_cr(" N. oops        = %d", native_oops_size);

  }

  int pc_desc_resets;   // number of resets (= number of caches)

  int pc_desc_queries;  // queries to nmethod::find_pc_desc

  int pc_desc_approx;   // number of those which have approximate true

  int pc_desc_repeats;  // number of _last_pc_desc hits

  int pc_desc_hits;     // number of LRU cache hits

  int pc_desc_tests;    // total number of PcDesc examinations

  int pc_desc_searches; // total number of quasi-binary search steps

  int pc_desc_adds;     // number of LUR cache insertions

  void print_pc_stats() {

    tty->print_cr("PcDesc Statistics:  %d queries, %.2f comparisons per query",

                  pc_desc_queries,

                  (double)(pc_desc_tests + pc_desc_searches)

                  / pc_desc_queries);

    tty->print_cr("  caches=%d queries=%d/%d, hits=%d+%d, tests=%d+%d, adds=%d",

                  pc_desc_resets,

                  pc_desc_queries, pc_desc_approx,

                  pc_desc_repeats, pc_desc_hits,

                  pc_desc_tests, pc_desc_searches, pc_desc_adds);

  }

} nmethod_stats;

#endif //PRODUCT

//---------------------------------------------------------------------------------

// The _unwind_handler is a special marker address, which says that

// for given exception oop and address, the frame should be removed

// as the tuple cannot be caught in the nmethod

address ExceptionCache::_unwind_handler = (address) -1;

ExceptionCache::ExceptionCache(Handle exception, address pc, address handler) {

  assert(pc != NULL, "Must be non null");

  assert(exception.not_null(), "Must be non null");

  assert(handler != NULL, "Must be non null");

  _count = 0;

  _exception_type = exception->klass();

  _next = NULL;

  add_address_and_handler(pc,handler);

}

address ExceptionCache::match(Handle exception, address pc) {

  assert(pc != NULL,"Must be non null");

  assert(exception.not_null(),"Must be non null");

  if (exception->klass() == exception_type()) {

    return (test_address(pc));

  }

  return NULL;

}

bool ExceptionCache::match_exception_with_space(Handle exception) {

  assert(exception.not_null(),"Must be non null");

  if (exception->klass() == exception_type() && count() < cache_size) {

    return true;

  }

  return false;

}

address ExceptionCache::test_address(address addr) {

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

    if (pc_at(i) == addr) {

      return handler_at(i);

    }

  }

  return NULL;

}

bool ExceptionCache::add_address_and_handler(address addr, address handler) {

  if (test_address(addr) == handler) return true;

  if (count() < cache_size) {

    set_pc_at(count(),addr);

    set_handler_at(count(), handler);

    increment_count();

    return true;

  }

  return false;

}

// private method for handling exception cache

// These methods are private, and used to manipulate the exception cache

// directly.

ExceptionCache* nmethod::exception_cache_entry_for_exception(Handle exception) {

  ExceptionCache* ec = exception_cache();

  while (ec != NULL) {

    if (ec->match_exception_with_space(exception)) {

      return ec;

    }

    ec = ec->next();

  }

  return NULL;

}

//-----------------------------------------------------------------------------

// Helper used by both find_pc_desc methods.

static inline bool match_desc(PcDesc* pc, int pc_offset, bool approximate) {

  NOT_PRODUCT(++nmethod_stats.pc_desc_tests);

  if (!approximate)

    return pc->pc_offset() == pc_offset;

  else

    return (pc-1)->pc_offset() < pc_offset && pc_offset <= pc->pc_offset();

}

void PcDescCache::reset_to(PcDesc* initial_pc_desc) {

  if (initial_pc_desc == NULL) {

    _last_pc_desc = NULL;  // native method

    return;

  }

  NOT_PRODUCT(++nmethod_stats.pc_desc_resets);

  // reset the cache by filling it with benign (non-null) values

  assert(initial_pc_desc->pc_offset() < 0, "must be sentinel");

  _last_pc_desc = initial_pc_desc + 1;  // first valid one is after sentinel

  for (int i = 0; i < cache_size; i++)

    _pc_descs[i] = initial_pc_desc;

}

PcDesc* PcDescCache::find_pc_desc(int pc_offset, bool approximate) {

  NOT_PRODUCT(++nmethod_stats.pc_desc_queries);

  NOT_PRODUCT(if (approximate)  ++nmethod_stats.pc_desc_approx);

  // In order to prevent race conditions do not load cache elements

  // repeatedly, but use a local copy:

  PcDesc* res;

  // Step one:  Check the most recently returned value.

  res = _last_pc_desc;

  if (res == NULL)  return NULL;  // native method; no PcDescs at all

  if (match_desc(res, pc_offset, approximate)) {

    NOT_PRODUCT(++nmethod_stats.pc_desc_repeats);

    return res;

  }

  // Step two:  Check the LRU cache.

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

    res = _pc_descs[i];

    if (res->pc_offset() < 0)  break;  // optimization: skip empty cache

    if (match_desc(res, pc_offset, approximate)) {

      NOT_PRODUCT(++nmethod_stats.pc_desc_hits);

      _last_pc_desc = res;  // record this cache hit in case of repeat

      return res;

    }

  }

  // Report failure.

  return NULL;

}

void PcDescCache::add_pc_desc(PcDesc* pc_desc) {

  NOT_PRODUCT(++nmethod_stats.pc_desc_adds);

  // Update the LRU cache by shifting pc_desc forward:

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

    PcDesc* next = _pc_descs[i];

    _pc_descs[i] = pc_desc;

    pc_desc = next;

  }

  // Note:  Do not update _last_pc_desc.  It fronts for the LRU cache.

}

// adjust pcs_size so that it is a multiple of both oopSize and

// sizeof(PcDesc) (assumes that if sizeof(PcDesc) is not a multiple

// of oopSize, then 2*sizeof(PcDesc) is)

static int  adjust_pcs_size(int pcs_size) {

  int nsize = round_to(pcs_size,   oopSize);

  if ((nsize % sizeof(PcDesc)) != 0) {

    nsize = pcs_size + sizeof(PcDesc);

  }

  assert((nsize %  oopSize) == 0, "correct alignment");

  return nsize;

}

//-----------------------------------------------------------------------------

void nmethod::add_exception_cache_entry(ExceptionCache* new_entry) {

  assert(ExceptionCache_lock->owned_by_self(),"Must hold the ExceptionCache_lock");

  assert(new_entry != NULL,"Must be non null");

  assert(new_entry->next() == NULL, "Must be null");

  if (exception_cache() != NULL) {

    new_entry->set_next(exception_cache());

  }

  set_exception_cache(new_entry);

}

void nmethod::remove_from_exception_cache(ExceptionCache* ec) {

  ExceptionCache* prev = NULL;

  ExceptionCache* curr = exception_cache();

  assert(curr != NULL, "nothing to remove");

  // find the previous and next entry of ec

  while (curr != ec) {

    prev = curr;

    curr = curr->next();

    assert(curr != NULL, "ExceptionCache not found");

  }

  // now: curr == ec

  ExceptionCache* next = curr->next();

  if (prev == NULL) {

    set_exception_cache(next);

  } else {

    prev->set_next(next);

  }

  delete curr;

}

// public method for accessing the exception cache

// These are the public access methods.

address nmethod::handler_for_exception_and_pc(Handle exception, address pc) {

  // We never grab a lock to read the exception cache, so we may

  // have false negatives. This is okay, as it can only happen during

  // the first few exception lookups for a given nmethod.

  ExceptionCache* ec = exception_cache();

  while (ec != NULL) {

    address ret_val;

    if ((ret_val = ec->match(exception,pc)) != NULL) {

      return ret_val;

    }

    ec = ec->next();

  }

  return NULL;

}

void nmethod::add_handler_for_exception_and_pc(Handle exception, address pc, address handler) {

  // There are potential race conditions during exception cache updates, so we

  // must own the ExceptionCache_lock before doing ANY modifications. Because

  // we don't lock during reads, it is possible to have several threads attempt

  // to update the cache with the same data. We need to check for already inserted

  // copies of the current data before adding it.

  MutexLocker ml(ExceptionCache_lock);

  ExceptionCache* target_entry = exception_cache_entry_for_exception(exception);

  if (target_entry == NULL || !target_entry->add_address_and_handler(pc,handler)) {

    target_entry = new ExceptionCache(exception,pc,handler);

    add_exception_cache_entry(target_entry);

  }

}

//-------------end of code for ExceptionCache--------------

void nmFlags::clear() {

  assert(sizeof(nmFlags) == sizeof(int), "using more than one word for nmFlags");

  *(jint*)this = 0;

}

int nmethod::total_size() const {

  return

    code_size()          +

    stub_size()          +

    consts_size()        +

    scopes_data_size()   +

    scopes_pcs_size()    +

    handler_table_size() +

    nul_chk_table_size();

}

const char* nmethod::compile_kind() const {

  if (method() == NULL)    return "unloaded";

  if (is_native_method())  return "c2n";

  if (is_osr_method())     return "osr";

  return NULL;

}

// %%% This variable is no longer used?

int nmethod::_zombie_instruction_size = NativeJump::instruction_size;

nmethod* nmethod::new_native_nmethod(methodHandle method,

  CodeBuffer *code_buffer,

  int vep_offset,

  int frame_complete,

  int frame_size,

  ByteSize basic_lock_owner_sp_offset,

  ByteSize basic_lock_sp_offset,

  OopMapSet* oop_maps) {

  // create nmethod

  nmethod* nm = NULL;

  {

    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    int native_nmethod_size = allocation_size(code_buffer, sizeof(nmethod));

    CodeOffsets offsets;

    offsets.set_value(CodeOffsets::Verified_Entry, vep_offset);

    offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);

    nm = new (native_nmethod_size)

      nmethod(method(), native_nmethod_size, &offsets,

              code_buffer, frame_size,

              basic_lock_owner_sp_offset, basic_lock_sp_offset,

              oop_maps);

    NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_native_nmethod(nm));

    if (PrintAssembly && nm != NULL)

      Disassembler::decode(nm);

  }

  // verify nmethod

  debug_only(if (nm) nm->verify();) // might block

  if (nm != NULL) {

    nm->log_new_nmethod();

  }

  return nm;

}

#ifdef HAVE_DTRACE_H

nmethod* nmethod::new_dtrace_nmethod(methodHandle method,

                                     CodeBuffer *code_buffer,

                                     int vep_offset,

                                     int trap_offset,

                                     int frame_complete,

                                     int frame_size) {

  // create nmethod

  nmethod* nm = NULL;

  {

    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    int nmethod_size = allocation_size(code_buffer, sizeof(nmethod));

    CodeOffsets offsets;

    offsets.set_value(CodeOffsets::Verified_Entry, vep_offset);

    offsets.set_value(CodeOffsets::Dtrace_trap, trap_offset);

    offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);

    nm = new (nmethod_size) nmethod(method(), nmethod_size, &offsets, code_buffer, frame_size);

    NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_nmethod(nm));

    if (PrintAssembly && nm != NULL)

      Disassembler::decode(nm);

  }

  // verify nmethod

  debug_only(if (nm) nm->verify();) // might block

  if (nm != NULL) {

    nm->log_new_nmethod();

  }

  return nm;

}

#endif // def HAVE_DTRACE_H

nmethod* nmethod::new_nmethod(methodHandle method,

  int compile_id,

  int entry_bci,

  CodeOffsets* offsets,

  int orig_pc_offset,

  DebugInformationRecorder* debug_info,

  Dependencies* dependencies,

  CodeBuffer* code_buffer, int frame_size,

  OopMapSet* oop_maps,

  ExceptionHandlerTable* handler_table,

  ImplicitExceptionTable* nul_chk_table,

  AbstractCompiler* compiler,

  int comp_level

)

{

  assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");

  // create nmethod

  nmethod* nm = NULL;

  { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    int nmethod_size =

      allocation_size(code_buffer, sizeof(nmethod))

      + adjust_pcs_size(debug_info->pcs_size())

      + round_to(dependencies->size_in_bytes() , oopSize)

      + round_to(handler_table->size_in_bytes(), oopSize)

      + round_to(nul_chk_table->size_in_bytes(), oopSize)

      + round_to(debug_info->data_size()       , oopSize);

    nm = new (nmethod_size)

      nmethod(method(), nmethod_size, compile_id, entry_bci, offsets,

              orig_pc_offset, debug_info, dependencies, code_buffer, frame_size,

              oop_maps,