/*

 * Copyright (c) 1999, 2012, 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 "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/codeCache.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/compilerOracle.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/allocation.inline.hpp"

#include "oops/methodDataOop.hpp"

#include "oops/methodOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/arguments.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/os.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/sweeper.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#ifdef COMPILER1

#include "c1/c1_Compiler.hpp"

#endif

#ifdef COMPILER2

#include "opto/c2compiler.hpp"

#endif

#ifdef SHARK

#include "shark/sharkCompiler.hpp"

#endif

#ifdef DTRACE_ENABLED

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

#ifndef USDT2

HS_DTRACE_PROBE_DECL8(hotspot, method__compile__begin,

  char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t);

HS_DTRACE_PROBE_DECL9(hotspot, method__compile__end,

  char*, intptr_t, char*, intptr_t, char*, intptr_t, char*, intptr_t, bool);

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)              \

  {                                                                      \

    char* comp_name = (char*)(compiler)->name();                         \

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

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

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

    HS_DTRACE_PROBE8(hotspot, method__compile__begin,                    \

      comp_name, strlen(comp_name),                                      \

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

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

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

  }

#define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)       \

  {                                                                      \

    char* comp_name = (char*)(compiler)->name();                         \

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

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

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

    HS_DTRACE_PROBE9(hotspot, method__compile__end,                      \

      comp_name, strlen(comp_name),                                      \

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

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

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

  }

#else /* USDT2 */

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)              \

  {                                                                      \

    char* comp_name = (char*)(compiler)->name();                         \

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

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

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

    HOTSPOT_METHOD_COMPILE_BEGIN(                                       \

      comp_name, strlen(comp_name),                                      \

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

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

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

  }

#define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)       \

  {                                                                      \

    char* comp_name = (char*)(compiler)->name();                         \

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

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

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

    HOTSPOT_METHOD_COMPILE_END(                                          \

      comp_name, strlen(comp_name),                                      \

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

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

      (char *) signature->bytes(), signature->utf8_length(), (success)); \

  }

#endif /* USDT2 */

#else //  ndef DTRACE_ENABLED

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(compiler, method)

#define DTRACE_METHOD_COMPILE_END_PROBE(compiler, method, success)

#endif // ndef DTRACE_ENABLED

bool CompileBroker::_initialized = false;

volatile bool CompileBroker::_should_block = false;

volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;

// The installed compiler(s)

AbstractCompiler* CompileBroker::_compilers[2];

// These counters are used for assigning id's to each compilation

uint CompileBroker::_compilation_id        = 0;

uint CompileBroker::_osr_compilation_id    = 0;

// Debugging information

int  CompileBroker::_last_compile_type     = no_compile;

int  CompileBroker::_last_compile_level    = CompLevel_none;

char CompileBroker::_last_method_compiled[CompileBroker::name_buffer_length];

// Performance counters

PerfCounter* CompileBroker::_perf_total_compilation = NULL;

PerfCounter* CompileBroker::_perf_osr_compilation = NULL;

PerfCounter* CompileBroker::_perf_standard_compilation = NULL;

PerfCounter* CompileBroker::_perf_total_bailout_count = NULL;

PerfCounter* CompileBroker::_perf_total_invalidated_count = NULL;

PerfCounter* CompileBroker::_perf_total_compile_count = NULL;

PerfCounter* CompileBroker::_perf_total_osr_compile_count = NULL;

PerfCounter* CompileBroker::_perf_total_standard_compile_count = NULL;

PerfCounter* CompileBroker::_perf_sum_osr_bytes_compiled = NULL;

PerfCounter* CompileBroker::_perf_sum_standard_bytes_compiled = NULL;

PerfCounter* CompileBroker::_perf_sum_nmethod_size = NULL;

PerfCounter* CompileBroker::_perf_sum_nmethod_code_size = NULL;

PerfStringVariable* CompileBroker::_perf_last_method = NULL;

PerfStringVariable* CompileBroker::_perf_last_failed_method = NULL;

PerfStringVariable* CompileBroker::_perf_last_invalidated_method = NULL;

PerfVariable*       CompileBroker::_perf_last_compile_type = NULL;

PerfVariable*       CompileBroker::_perf_last_compile_size = NULL;

PerfVariable*       CompileBroker::_perf_last_failed_type = NULL;

PerfVariable*       CompileBroker::_perf_last_invalidated_type = NULL;

// Timers and counters for generating statistics

elapsedTimer CompileBroker::_t_total_compilation;

elapsedTimer CompileBroker::_t_osr_compilation;

elapsedTimer CompileBroker::_t_standard_compilation;

int CompileBroker::_total_bailout_count          = 0;

int CompileBroker::_total_invalidated_count      = 0;

int CompileBroker::_total_compile_count          = 0;

int CompileBroker::_total_osr_compile_count      = 0;

int CompileBroker::_total_standard_compile_count = 0;

int CompileBroker::_sum_osr_bytes_compiled       = 0;

int CompileBroker::_sum_standard_bytes_compiled  = 0;

int CompileBroker::_sum_nmethod_size             = 0;

int CompileBroker::_sum_nmethod_code_size        = 0;

CompileQueue* CompileBroker::_c2_method_queue   = NULL;

CompileQueue* CompileBroker::_c1_method_queue   = NULL;

CompileTask*  CompileBroker::_task_free_list = NULL;

GrowableArray<CompilerThread*>* CompileBroker::_method_threads = NULL;

class CompilationLog : public StringEventLog {

 public:

  CompilationLog() : StringEventLog("Compilation events") {

  }

  void log_compile(JavaThread* thread, CompileTask* task) {

    StringLogMessage lm;

    stringStream msg = lm.stream();

    // msg.time_stamp().update_to(tty->time_stamp().ticks());

    task->print_compilation(&msg, true);

    log(thread, "%s", (const char*)lm);

  }

  void log_nmethod(JavaThread* thread, nmethod* nm) {

    log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]",

        nm->compile_id(), nm->is_osr_method() ? "%" : "",

        nm, nm->code_begin(), nm->code_end());

  }

  void log_failure(JavaThread* thread, CompileTask* task, const char* reason, const char* retry_message) {

    StringLogMessage lm;

    lm.print("%4d   COMPILE SKIPPED: %s", task->compile_id(), reason);

    if (retry_message != NULL) {

      lm.append(" (%s)", retry_message);

    }

    lm.print("\n");

    log(thread, "%s", (const char*)lm);

  }

};

static CompilationLog* _compilation_log = NULL;

void compileBroker_init() {

  if (LogEvents) {

    _compilation_log = new CompilationLog();

  }

}

CompileTaskWrapper::CompileTaskWrapper(CompileTask* task) {

  CompilerThread* thread = CompilerThread::current();

  thread->set_task(task);

  CompileLog*     log  = thread->log();

  if (log != NULL)  task->log_task_start(log);

}

CompileTaskWrapper::~CompileTaskWrapper() {

  CompilerThread* thread = CompilerThread::current();

  CompileTask* task = thread->task();

  CompileLog*  log  = thread->log();

  if (log != NULL)  task->log_task_done(log);

  thread->set_task(NULL);

  task->set_code_handle(NULL);

  DEBUG_ONLY(thread->set_env((ciEnv*)badAddress));

  if (task->is_blocking()) {

    MutexLocker notifier(task->lock(), thread);

    task->mark_complete();

    // Notify the waiting thread that the compilation has completed.

    task->lock()->notify_all();

  } else {

    task->mark_complete();

    // By convention, the compiling thread is responsible for

    // recycling a non-blocking CompileTask.

    CompileBroker::free_task(task);

  }

}

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

// CompileTask::initialize

void CompileTask::initialize(int compile_id,

                             methodHandle method,

                             int osr_bci,

                             int comp_level,

                             methodHandle hot_method,

                             int hot_count,

                             const char* comment,

                             bool is_blocking) {

  assert(!_lock->is_locked(), "bad locking");

  _compile_id = compile_id;

  _method = JNIHandles::make_global(method);

  _osr_bci = osr_bci;

  _is_blocking = is_blocking;

  _comp_level = comp_level;

  _num_inlined_bytecodes = 0;

  _is_complete = false;

  _is_success = false;

  _code_handle = NULL;

  _hot_method = NULL;

  _hot_count = hot_count;

  _time_queued = 0;  // tidy

  _comment = comment;

  if (LogCompilation) {

    _time_queued = os::elapsed_counter();

    if (hot_method.not_null()) {

      if (hot_method == method) {

        _hot_method = _method;

      } else {

        _hot_method = JNIHandles::make_global(hot_method);

      }

    }

  }

  _next = NULL;

}

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

// CompileTask::code/set_code

nmethod* CompileTask::code() const {

  if (_code_handle == NULL)  return NULL;

  return _code_handle->code();

}

void CompileTask::set_code(nmethod* nm) {

  if (_code_handle == NULL && nm == NULL)  return;

  guarantee(_code_handle != NULL, "");

  _code_handle->set_code(nm);

  if (nm == NULL)  _code_handle = NULL;  // drop the handle also

}

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

// CompileTask::free

void CompileTask::free() {

  set_code(NULL);

  assert(!_lock->is_locked(), "Should not be locked when freed");

  if (_hot_method != NULL && _hot_method != _method) {

    JNIHandles::destroy_global(_hot_method);

  }

  JNIHandles::destroy_global(_method);

}

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

// CompileTask::print

void CompileTask::print() {

  tty->print("<CompileTask compile_id=%d ", _compile_id);

  tty->print("method=");

  ((methodOop)JNIHandles::resolve(_method))->print_name(tty);

  tty->print_cr(" osr_bci=%d is_blocking=%s is_complete=%s is_success=%s>",

             _osr_bci, bool_to_str(_is_blocking),

             bool_to_str(_is_complete), bool_to_str(_is_success));

}

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

// CompileTask::print_line_on_error

//

// This function is called by fatal error handler when the thread

// causing troubles is a compiler thread.

//

// Do not grab any lock, do not allocate memory.

//

// Otherwise it's the same as CompileTask::print_line()

//

void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) {

  // print compiler name

  st->print("%s:", CompileBroker::compiler(comp_level())->name());

  print_compilation(st);

}

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

// CompileTask::print_line

void CompileTask::print_line() {

  ttyLocker ttyl;  // keep the following output all in one block

  // print compiler name if requested

  if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler(comp_level())->name());

  print_compilation();

}

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

// CompileTask::print_compilation_impl

void CompileTask::print_compilation_impl(outputStream* st, methodOop method, int compile_id, int comp_level,

                                         bool is_osr_method, int osr_bci, bool is_blocking,

                                         const char* msg, bool short_form) {

  if (!short_form) {

    st->print("%7d ", (int) st->time_stamp().milliseconds());  // print timestamp

  }

  st->print("%4d ", compile_id);    // print compilation number

  // For unloaded methods the transition to zombie occurs after the

  // method is cleared so it's impossible to report accurate

  // information for that case.

  bool is_synchronized = false;

  bool has_exception_handler = false;

  bool is_native = false;

  if (method != NULL) {

    is_synchronized       = method->is_synchronized();

    has_exception_handler = method->has_exception_handler();

    is_native             = method->is_native();

  }

  // method attributes

  const char compile_type   = is_osr_method                   ? '%' : ' ';

  const char sync_char      = is_synchronized                 ? 's' : ' ';

  const char exception_char = has_exception_handler           ? '!' : ' ';

  const char blocking_char  = is_blocking                     ? 'b' : ' ';

  const char native_char    = is_native                       ? 'n' : ' ';

  // print method attributes

  st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, native_char);

  if (TieredCompilation) {

    if (comp_level != -1)  st->print("%d ", comp_level);

    else                   st->print("- ");

  }

  st->print("     ");  // more indent

  if (method == NULL) {

    st->print("(method)");

  } else {

    method->print_short_name(st);

    if (is_osr_method) {

      st->print(" @ %d", osr_bci);

    }

  }

  if (msg != NULL) {

    st->print("   %s", msg);

  }

  if (!short_form) {

    st->cr();

  }

}

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

// CompileTask::print_inlining

void CompileTask::print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) {

  //         1234567

  st->print("        ");     // print timestamp

  //         1234

  st->print("     ");        // print compilation number

  // method attributes

  if (TieredCompilation) {

    st->print("  ");

  }

  st->print("     ");        // more indent

  st->print("    ");         // initial inlining indent

  for (int i = 0; i < inline_level; i++)  st->print("  ");

  st->print("@ %d  ", bci);  // print bci

  method->print_short_name(st);

  if (msg != NULL) {

    st->print("   %s", msg);

  }

  st->cr();

}

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

// CompileTask::print_inline_indent

void CompileTask::print_inline_indent(int inline_level, outputStream* st) {

  //         1234567

  st->print("        ");     // print timestamp

  //         1234

  st->print("     ");        // print compilation number

  //         %s!bn

  st->print("      ");       // print method attributes

  if (TieredCompilation) {

    st->print("  ");

  }

  st->print("     ");        // more indent

  st->print("    ");         // initial inlining indent

  for (int i = 0; i < inline_level; i++)  st->print("  ");

}

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

// CompileTask::print_compilation

void CompileTask::print_compilation(outputStream* st, bool short_form) {

  oop rem = JNIHandles::resolve(method_handle());

  assert(rem != NULL && rem->is_method(), "must be");

  methodOop method = (methodOop) rem;

  bool is_osr_method = osr_bci() != InvocationEntryBci;

  print_compilation_impl(st, method, compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), NULL, short_form);

}

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

// CompileTask::log_task

void CompileTask::log_task(xmlStream* log) {

  Thread* thread = Thread::current();

  methodHandle method(thread,

                      (methodOop)JNIHandles::resolve(method_handle()));

  ResourceMark rm(thread);

  // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'>

  if (_compile_id != 0)   log->print(" compile_id='%d'", _compile_id);

  if (_osr_bci != CompileBroker::standard_entry_bci) {

    log->print(" compile_kind='osr'");  // same as nmethod::compile_kind

  } // else compile_kind='c2c'

  if (!method.is_null())  log->method(method);

  if (_osr_bci != CompileBroker::standard_entry_bci) {

    log->print(" osr_bci='%d'", _osr_bci);

  }