/*

 * Copyright (c) 1999, 2014, 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/methodData.hpp"

#include "oops/method.hpp"

#include "oops/oop.inline.hpp"

#include "prims/nativeLookup.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.inline.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 "trace/tracing.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

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)             \

  {                                                                      \

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

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

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

    HOTSPOT_METHOD_COMPILE_BEGIN(                                        \

      (char *) 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(method, comp_name, success)      \

  {                                                                      \

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

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

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

    HOTSPOT_METHOD_COMPILE_END(                                          \

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

  }

#else //  ndef DTRACE_ENABLED

#define DTRACE_METHOD_COMPILE_BEGIN_PROBE(method, comp_name)

#define DTRACE_METHOD_COMPILE_END_PROBE(method, comp_name, success)

#endif // ndef DTRACE_ENABLED

bool CompileBroker::_initialized = false;

volatile bool CompileBroker::_should_block = false;

volatile jint CompileBroker::_print_compilation_warning = 0;

volatile jint CompileBroker::_should_compile_new_jobs = run_compilation;

// The installed compiler(s)

AbstractCompiler* CompileBroker::_compilers[2];

// These counters are used to assign an unique ID to each compilation.

volatile jint CompileBroker::_compilation_id     = 0;

volatile jint 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;

long CompileBroker::_peak_compilation_time       = 0;

CompileQueue* CompileBroker::_c2_compile_queue   = NULL;

CompileQueue* CompileBroker::_c1_compile_queue   = NULL;

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

class CompilationLog : public StringEventLog {

 public:

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

  }

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

    StringLogMessage lm;

    stringStream sstr = lm.stream();

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

    task->print_compilation(&sstr, NULL, true, false);

    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() ? "%" : "",

        p2i(nm), p2i(nm->code_begin()), p2i(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);

  thread->set_env(NULL);

  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.

    CompileTask::free(task);

  }

}

CompileTask*  CompileTask::_task_free_list = NULL;

#ifdef ASSERT

int CompileTask::_num_allocated_tasks = 0;

#endif

/**

 * Allocate a CompileTask, from the free list if possible.

 */

CompileTask* CompileTask::allocate() {

  MutexLocker locker(CompileTaskAlloc_lock);

  CompileTask* task = NULL;

  if (_task_free_list != NULL) {

    task = _task_free_list;

    _task_free_list = task->next();

    task->set_next(NULL);

  } else {

    task = new CompileTask();

    DEBUG_ONLY(_num_allocated_tasks++;)

    assert (_num_allocated_tasks < 10000, "Leaking compilation tasks?");

    task->set_next(NULL);

    task->set_is_free(true);

  }

  assert(task->is_free(), "Task must be free.");

  task->set_is_free(false);

  return task;

}

/**

 * Add a task to the free list.

 */

void CompileTask::free(CompileTask* task) {

  MutexLocker locker(CompileTaskAlloc_lock);

  if (!task->is_free()) {

    task->set_code(NULL);

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

    JNIHandles::destroy_global(task->_method_holder);

    JNIHandles::destroy_global(task->_hot_method_holder);

    task->set_is_free(true);

    task->set_next(_task_free_list);

    _task_free_list = task;

  }

}

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

  _method_holder = JNIHandles::make_global(method->method_holder()->klass_holder());

  _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_method_holder = NULL;

  _hot_count = hot_count;

  _time_queued = 0;  // tidy

  _comment = comment;

  _failure_reason = NULL;

  if (LogCompilation) {

    _time_queued = os::elapsed_counter();

    if (hot_method.not_null()) {

      if (hot_method == method) {

        _hot_method = _method;

      } else {

        _hot_method = hot_method();

        // only add loader or mirror if different from _method_holder

        _hot_method_holder = JNIHandles::make_global(hot_method->method_holder()->klass_holder());

      }

    }

  }

  _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

}

void CompileTask::mark_on_stack() {

  // Mark these methods as something redefine classes cannot remove.

  _method->set_on_stack(true);

  if (_hot_method != NULL) {

    _hot_method->set_on_stack(true);

  }

}

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

// 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_name(comp_level()));

  print_compilation(st);

}

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

// CompileTask::print_line

void CompileTask::print_tty() {

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

  // print compiler name if requested

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

    print_compilation(tty);

}

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

// CompileTask::print_compilation_impl

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

                                         bool is_osr_method, int osr_bci, bool is_blocking,

                                         const char* msg, bool short_form, bool cr) {

  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 (method->is_native())

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

    else

      st->print(" (%d bytes)", method->code_size());

  }

  if (msg != NULL) {

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

  }

  if (cr) {

    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 (method->is_loaded()) {

    const char sync_char      = method->is_synchronized()        ? 's' : ' ';

    const char exception_char = method->has_exception_handlers() ? '!' : ' ';

    const char monitors_char  = method->has_monitor_bytecodes()  ? 'm' : ' ';

    // print method attributes

    st->print(" %c%c%c  ", sync_char, exception_char, monitors_char);

  } else {

    //         %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("  ");

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

  method->print_short_name(st);

  if (method->is_loaded())

    st->print(" (%d bytes)", method->code_size());

  else

    st->print(" (not loaded)");

  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, const char* msg, bool short_form, bool cr) {

  bool is_osr_method = osr_bci() != InvocationEntryBci;

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

}

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

// CompileTask::log_task

void CompileTask::log_task(xmlStream* log) {

  Thread* thread = Thread::current();

  methodHandle method(thread, this->method());

  ResourceMark rm(thread);

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

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