/*

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

 *

 */

#include "precompiled.hpp"

#include "code/codeCache.hpp"

#include "code/compiledIC.hpp"

#include "code/nmethod.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerOracle.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/bytecode.hpp"

#include "oops/methodDataOop.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "prims/jvmtiImpl.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/sweeper.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/xmlstream.hpp"

#ifdef SHARK

#include "shark/sharkCompiler.hpp"

#endif

#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) {                                                      \

      Symbol* klass_name = m->klass_name();                               \

      Symbol* name = m->name();                                           \

      Symbol* 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 (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing

  if (is_native_method()) return false;

  return compiler()->is_c1();

}

bool nmethod::is_compiled_by_c2() const {

  if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing

  if (is_native_method()) return false;

  return compiler()->is_c2();

}

bool nmethod::is_compiled_by_shark() const {

  if (is_native_method()) return false;

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

  return compiler()->is_shark();

}

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

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

  int insts_size;

  int stub_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();

    consts_size         += nm->consts_size();

    insts_size          += nm->insts_size();

    stub_size           += nm->stub_size();

    oops_size           += nm->oops_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();

  }

  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 (consts_size != 0)         tty->print_cr(" constants      = %d", consts_size);

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

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

    if (oops_size != 0)           tty->print_cr(" oops           = %d", oops_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);

  }

  int native_nmethod_count;

  int native_total_size;

  int native_relocation_size;

  int native_insts_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_insts_size       += nm->insts_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_insts_size != 0)       tty->print_cr(" N. main code   = %d", native_insts_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 _pc_descs[0] 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

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

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

    _pc_descs[0] = NULL; // native method; no PcDescs at all

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

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

  // Note: one might think that caching the most recently

  // read value separately would be a win, but one would be

  // wrong.  When many threads are updating it, the cache

  // line it's in would bounce between caches, negating

  // any benefit.

  // 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 added value.

  res = _pc_descs[0];

  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 rest of the LRU cache.

  for (int i = 1; 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);

      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;

  }

}

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

int nmethod::total_size() const {

  return

    consts_size()        +

    insts_size()         +

    stub_size()          +

    scopes_data_size()   +

    scopes_pcs_size()    +

    handler_table_size() +

    nul_chk_table_size();

}

const char* nmethod::compile_kind() const {

  if (is_osr_method())     return "osr";

  if (method() != NULL && is_native_method())  return "c2n";

  return NULL;

}

// Fill in default values for various flag fields

void nmethod::init_defaults() {

  _state                      = alive;

  _marked_for_reclamation     = 0;

  _has_flushed_dependencies   = 0;

  _speculatively_disconnected = 0;

  _has_unsafe_access          = 0;

  _has_method_handle_invokes  = 0;

  _marked_for_deoptimization  = 0;

  _lock_count                 = 0;

  _stack_traversal_mark       = 0;

  _unload_reported            = false;           // jvmti state

  NOT_PRODUCT(_has_debug_info = false);

#ifdef ASSERT

  _oops_are_stale             = false;

#endif

  _oops_do_mark_link       = NULL;

  _jmethod_id              = NULL;

  _osr_link                = NULL;

  _scavenge_root_link      = NULL;

  _scavenge_root_state     = 0;

  _saved_nmethod_link      = NULL;

  _compiler                = NULL;

#ifdef HAVE_DTRACE_H

  _trap_offset             = 0;

#endif // def HAVE_DTRACE_H

}

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)

              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;