/*

 * Copyright (c) 1999, 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 "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"

#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

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

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

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

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

  // method attributes

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

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

  // 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 (msg != NULL) {

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

  }

  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

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

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

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

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

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

}

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

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

  }

  if (_comp_level != CompLevel_highest_tier) {

    log->print(" level='%d'", _comp_level);

  }

  if (_is_blocking) {

    log->print(" blocking='1'");

  }

  log->stamp();

}

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

// CompileTask::log_task_queued

void CompileTask::log_task_queued() {

  Thread* thread = Thread::current();

  ttyLocker ttyl;

  ResourceMark rm(thread);

  xtty->begin_elem("task_queued");

  log_task(xtty);

  if (_comment != NULL) {

    xtty->print(" comment='%s'", _comment);

  }

  if (_hot_method != NULL) {

    methodHandle hot(thread,

                     (methodOop)JNIHandles::resolve(_hot_method));

    methodHandle method(thread,

                        (methodOop)JNIHandles::resolve(_method));

    if (hot() != method()) {

      xtty->method(hot);

    }

  }

  if (_hot_count != 0) {

    xtty->print(" hot_count='%d'", _hot_count);

  }

  xtty->end_elem();

}

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

// CompileTask::log_task_start

void CompileTask::log_task_start(CompileLog* log)   {

  log->begin_head("task");

  log_task(log);

  log->end_head();

}

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

// CompileTask::log_task_done

void CompileTask::log_task_done(CompileLog* log) {

  Thread* thread = Thread::current();

  methodHandle method(thread,

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

  ResourceMark rm(thread);

  // <task_done ... stamp='1.234'>  </task>

  nmethod* nm = code();

  log->begin_elem("task_done success='%d' nmsize='%d' count='%d'",

                  _is_success, nm == NULL ? 0 : nm->content_size(),

                  method->invocation_count());

  int bec = method->backedge_count();

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

  // Note:  "_is_complete" is about to be set, but is not.

  if (_num_inlined_bytecodes != 0) {

    log->print(" inlined_bytes='%d'", _num_inlined_bytecodes);

  }

  log->stamp();

  log->end_elem();

  log->tail("task");

  log->clear_identities();   // next task will have different CI

  if (log->unflushed_count() > 2000) {

    log->flush();

  }

  log->mark_file_end();

}

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

// CompileQueue::add

//

// Add a CompileTask to a CompileQueue

void CompileQueue::add(CompileTask* task) {

  assert(lock()->owned_by_self(), "must own lock");

  task->set_next(NULL);

  task->set_prev(NULL);

  if (_last == NULL) {

    // The compile queue is empty.

    assert(_first == NULL, "queue is empty");

    _first = task;

    _last = task;