/*

 * Copyright (c) 1997, 2015, 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/dependencies.hpp"

#include "code/nativeInst.hpp"

#include "code/nmethod.hpp"

#include "code/scopeDesc.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerDirectives.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/bytecode.hpp"

#include "oops/methodData.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiRedefineClassesTrace.hpp"

#include "prims/jvmtiImpl.hpp"

#include "runtime/atomic.inline.hpp"

#include "runtime/orderAccess.inline.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/sweeper.hpp"

#include "utilities/resourceHash.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/xmlstream.hpp"

#ifdef TARGET_ARCH_x86

# include "nativeInst_x86.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "nativeInst_sparc.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "nativeInst_zero.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "nativeInst_arm.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "nativeInst_ppc.hpp"

#endif

#ifdef SHARK

#include "shark/sharkCompiler.hpp"

#endif

#if INCLUDE_JVMCI

#include "jvmci/jvmciJavaClasses.hpp"

#endif

unsigned char nmethod::_global_unloading_clock = 0;

#ifdef DTRACE_ENABLED

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

#define DTRACE_METHOD_UNLOAD_PROBE(method)                                \

  {                                                                       \

    Method* m = (method);                                                 \

    if (m != NULL) {                                                      \

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

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

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

      HOTSPOT_COMPILED_METHOD_UNLOAD(                                     \

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

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

        (char *) 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) {

    return false;

  }

  return compiler()->is_c1();

}

bool nmethod::is_compiled_by_jvmci() const {

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

  if (is_native_method()) return false;

  return compiler()->is_jvmci();

}

bool nmethod::is_compiled_by_c2() const {

  if (compiler() == NULL) {

    return false;

  }

  return compiler()->is_c2();

}

bool nmethod::is_compiled_by_shark() const {

  if (compiler() == NULL) {

    return false;

  }

  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.

struct java_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;

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

    metadata_size       += nm->metadata_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(const char* name) {

    if (nmethod_count == 0)  return;

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

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

    if (nmethod_count != 0)       tty->print_cr(" header         = " SIZE_FORMAT, nmethod_count * sizeof(nmethod));

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

  }

};

struct native_nmethod_stats_struct {

  int native_nmethod_count;

  int native_total_size;

  int native_relocation_size;

  int native_insts_size;

  int native_oops_size;

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

    native_metadata_size    += nm->metadata_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);

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

  }

};

struct pc_nmethod_stats_struct {

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

  }

};

#ifdef COMPILER1

static java_nmethod_stats_struct c1_java_nmethod_stats;

#endif

#ifdef COMPILER2

static java_nmethod_stats_struct c2_java_nmethod_stats;

#endif

#if INCLUDE_JVMCI

static java_nmethod_stats_struct jvmci_java_nmethod_stats;

#endif

#ifdef SHARK

static java_nmethod_stats_struct shark_java_nmethod_stats;

#endif

static java_nmethod_stats_struct unknown_java_nmethod_stats;

static native_nmethod_stats_struct native_nmethod_stats;

static pc_nmethod_stats_struct pc_nmethod_stats;

static void note_java_nmethod(nmethod* nm) {

#ifdef COMPILER1

  if (nm->is_compiled_by_c1()) {

    c1_java_nmethod_stats.note_nmethod(nm);

  } else

#endif

#ifdef COMPILER2

  if (nm->is_compiled_by_c2()) {

    c2_java_nmethod_stats.note_nmethod(nm);

  } else

#endif

#if INCLUDE_JVMCI

  if (nm->is_compiled_by_jvmci()) {

    jvmci_java_nmethod_stats.note_nmethod(nm);

  } else

#endif

#ifdef SHARK

  if (nm->is_compiled_by_shark()) {

    shark_java_nmethod_stats.note_nmethod(nm);

  } else

#endif

  {

    unknown_java_nmethod_stats.note_nmethod(nm);

  }

}

#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(++pc_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(++pc_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(++pc_nmethod_stats.pc_desc_queries);

  NOT_PRODUCT(if (approximate) ++pc_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(++pc_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(++pc_nmethod_stats.pc_desc_hits);

      return res;

    }

  }

  // Report failure.

  return NULL;

}

void PcDescCache::add_pc_desc(PcDesc* pc_desc) {

  NOT_PRODUCT(++pc_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::clean_exception_cache(BoolObjectClosure* is_alive) {

  ExceptionCache* prev = NULL;

  ExceptionCache* curr = exception_cache();

  while (curr != NULL) {

    ExceptionCache* next = curr->next();

    Klass* ex_klass = curr->exception_type();

    if (ex_klass != NULL && !ex_klass->is_loader_alive(is_alive)) {

      if (prev == NULL) {

        set_exception_cache(next);

      } else {

        prev->set_next(next);

      }

      delete curr;

      // prev stays the same.

    } else {

      prev = curr;

    }

    curr = next;

  }

}

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