/*

 * Copyright (c) 1997, 2018, 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 "jvm.h"

#include "code/codeCache.hpp"

#include "code/compiledIC.hpp"

#include "code/compiledMethod.inline.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/directivesParser.hpp"

#include "compiler/disassembler.hpp"

#include "interpreter/bytecode.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "oops/access.inline.hpp"

#include "oops/method.inline.hpp"

#include "oops/methodData.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiImpl.hpp"

#include "runtime/atomic.hpp"

#include "runtime/flags/flagSetting.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/os.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/sweeper.hpp"

#include "runtime/vmThread.hpp"

#include "utilities/align.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/resourceHash.hpp"

#include "utilities/xmlstream.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmciJavaClasses.hpp"

#endif

#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

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

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

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

  {

    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;

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

  int limit = count();

  for (int i = 0; i < limit; 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;

  int index = count();

  if (index < cache_size) {

    set_pc_at(index, addr);

    set_handler_at(index, handler);

    increment_count();

    return true;

  }

  return false;

}

ExceptionCache* ExceptionCache::next() {

  return Atomic::load(&_next);

}

void ExceptionCache::set_next(ExceptionCache *ec) {

  Atomic::store(ec, &_next);

}

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

// 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 = align_up(pcs_size,   oopSize);

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

    nsize = pcs_size + sizeof(PcDesc);

  }

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

  return nsize;

}

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

}

address* nmethod::orig_pc_addr(const frame* fr) {

  return (address*) ((address)fr->unextended_sp() + _orig_pc_offset);

}

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                      = not_installed;

  _has_flushed_dependencies   = 0;

  _lock_count                 = 0;

  _stack_traversal_mark       = 0;

  _unload_reported            = false; // jvmti state

  _is_far_code                = false; // nmethods are located in CodeCache

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

#if INCLUDE_RTM_OPT

  _rtm_state               = NoRTM;

#endif

#if INCLUDE_JVMCI

  _jvmci_installed_code   = NULL;

  _speculation_log        = NULL;

  _jvmci_installed_code_triggers_invalidation = false;

#endif

}

nmethod* nmethod::new_native_nmethod(const methodHandle& method,

  int compile_id,

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

  code_buffer->finalize_oop_references(method);

  // create nmethod

  nmethod* nm = NULL;

  {

    MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

    int native_nmethod_size = CodeBlob::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, CompLevel_none) nmethod(method(), compiler_none, native_nmethod_size,

                                            compile_id, &offsets,

                                            code_buffer, frame_size,

                                            basic_lock_owner_sp_offset,

                                            basic_lock_sp_offset, oop_maps);

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

  }

  if (nm != NULL) {

    // verify nmethod

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

    nm->log_new_nmethod();

    nm->make_in_use();

  }

  return nm;

}

nmethod* nmethod::new_nmethod(const 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

#if INCLUDE_JVMCI

  , jweak installed_code,

  jweak speculationLog

#endif

)

{

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

  code_buffer->finalize_oop_references(method);

  // create nmethod

  nmethod* nm = NULL;

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

    int nmethod_size =

      CodeBlob::allocation_size(code_buffer, sizeof(nmethod))

      + adjust_pcs_size(debug_info->pcs_size())

      + align_up((int)dependencies->size_in_bytes(), oopSize)

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