/*

 * Copyright 1999-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_c1_Runtime1.cpp.incl"

// Implementation of StubAssembler

StubAssembler::StubAssembler(CodeBuffer* code, const char * name, int stub_id) : C1_MacroAssembler(code) {

  _name = name;

  _must_gc_arguments = false;

  _frame_size = no_frame_size;

  _num_rt_args = 0;

  _stub_id = stub_id;

}

void StubAssembler::set_info(const char* name, bool must_gc_arguments) {

  _name = name;

  _must_gc_arguments = must_gc_arguments;

}

void StubAssembler::set_frame_size(int size) {

  if (_frame_size == no_frame_size) {

    _frame_size = size;

  }

  assert(_frame_size == size, "can't change the frame size");

}

void StubAssembler::set_num_rt_args(int args) {

  if (_num_rt_args == 0) {

    _num_rt_args = args;

  }

  assert(_num_rt_args == args, "can't change the number of args");

}

// Implementation of Runtime1

bool      Runtime1::_is_initialized = false;

CodeBlob* Runtime1::_blobs[Runtime1::number_of_ids];

const char *Runtime1::_blob_names[] = {

  RUNTIME1_STUBS(STUB_NAME, LAST_STUB_NAME)

};

#ifndef PRODUCT

// statistics

int Runtime1::_generic_arraycopy_cnt = 0;

int Runtime1::_primitive_arraycopy_cnt = 0;

int Runtime1::_oop_arraycopy_cnt = 0;

int Runtime1::_arraycopy_slowcase_cnt = 0;

int Runtime1::_new_type_array_slowcase_cnt = 0;

int Runtime1::_new_object_array_slowcase_cnt = 0;

int Runtime1::_new_instance_slowcase_cnt = 0;

int Runtime1::_new_multi_array_slowcase_cnt = 0;

int Runtime1::_monitorenter_slowcase_cnt = 0;

int Runtime1::_monitorexit_slowcase_cnt = 0;

int Runtime1::_patch_code_slowcase_cnt = 0;

int Runtime1::_throw_range_check_exception_count = 0;

int Runtime1::_throw_index_exception_count = 0;

int Runtime1::_throw_div0_exception_count = 0;

int Runtime1::_throw_null_pointer_exception_count = 0;

int Runtime1::_throw_class_cast_exception_count = 0;

int Runtime1::_throw_incompatible_class_change_error_count = 0;

int Runtime1::_throw_array_store_exception_count = 0;

int Runtime1::_throw_count = 0;

#endif

BufferBlob* Runtime1::_buffer_blob  = NULL;

// Simple helper to see if the caller of a runtime stub which

// entered the VM has been deoptimized

static bool caller_is_deopted() {

  JavaThread* thread = JavaThread::current();

  RegisterMap reg_map(thread, false);

  frame runtime_frame = thread->last_frame();

  frame caller_frame = runtime_frame.sender(&reg_map);

  assert(caller_frame.is_compiled_frame(), "must be compiled");

  return caller_frame.is_deoptimized_frame();

}

// Stress deoptimization

static void deopt_caller() {

  if ( !caller_is_deopted()) {

    JavaThread* thread = JavaThread::current();

    RegisterMap reg_map(thread, false);

    frame runtime_frame = thread->last_frame();

    frame caller_frame = runtime_frame.sender(&reg_map);

    VM_DeoptimizeFrame deopt(thread, caller_frame.id());

    VMThread::execute(&deopt);

    assert(caller_is_deopted(), "Must be deoptimized");

  }

}

BufferBlob* Runtime1::get_buffer_blob() {

  // Allocate code buffer space only once

  BufferBlob* blob = _buffer_blob;

  if (blob == NULL) {

    // setup CodeBuffer.  Preallocate a BufferBlob of size

    // NMethodSizeLimit plus some extra space for constants.

    int code_buffer_size = desired_max_code_buffer_size() + desired_max_constant_size();

    blob = BufferBlob::create("Compiler1 temporary CodeBuffer",

                              code_buffer_size);

    guarantee(blob != NULL, "must create initial code buffer");

    _buffer_blob = blob;

  }

  return _buffer_blob;

}

void Runtime1::setup_code_buffer(CodeBuffer* code, int call_stub_estimate) {

  // Preinitialize the consts section to some large size:

  int locs_buffer_size = 20 * (relocInfo::length_limit + sizeof(relocInfo));

  char* locs_buffer = NEW_RESOURCE_ARRAY(char, locs_buffer_size);

  code->insts()->initialize_shared_locs((relocInfo*)locs_buffer,

                                        locs_buffer_size / sizeof(relocInfo));

  code->initialize_consts_size(desired_max_constant_size());

  // Call stubs + deopt/exception handler

  code->initialize_stubs_size((call_stub_estimate * LIR_Assembler::call_stub_size) +

                              LIR_Assembler::exception_handler_size +

                              LIR_Assembler::deopt_handler_size);

}

void Runtime1::generate_blob_for(StubID id) {

  assert(0 <= id && id < number_of_ids, "illegal stub id");

  ResourceMark rm;

  // create code buffer for code storage

  CodeBuffer code(get_buffer_blob()->instructions_begin(),

                  get_buffer_blob()->instructions_size());

  setup_code_buffer(&code, 0);

  // create assembler for code generation

  StubAssembler* sasm = new StubAssembler(&code, name_for(id), id);

  // generate code for runtime stub

  OopMapSet* oop_maps;

  oop_maps = generate_code_for(id, sasm);

  assert(oop_maps == NULL || sasm->frame_size() != no_frame_size,

         "if stub has an oop map it must have a valid frame size");

#ifdef ASSERT

  // Make sure that stubs that need oopmaps have them

  switch (id) {

    // These stubs don't need to have an oopmap

    case dtrace_object_alloc_id:

    case slow_subtype_check_id:

    case fpu2long_stub_id:

    case unwind_exception_id:

#ifndef TIERED

    case counter_overflow_id: // Not generated outside the tiered world

#endif

#ifdef SPARC

    case handle_exception_nofpu_id:  // Unused on sparc

#endif

      break;

    // All other stubs should have oopmaps

    default:

      assert(oop_maps != NULL, "must have an oopmap");

  }

#endif

  // align so printing shows nop's instead of random code at the end (SimpleStubs are aligned)

  sasm->align(BytesPerWord);

  // make sure all code is in code buffer

  sasm->flush();

  // create blob - distinguish a few special cases

  CodeBlob* blob = RuntimeStub::new_runtime_stub(name_for(id),

                                                 &code,

                                                 CodeOffsets::frame_never_safe,

                                                 sasm->frame_size(),

                                                 oop_maps,

                                                 sasm->must_gc_arguments());

  // install blob

  assert(blob != NULL, "blob must exist");

  _blobs[id] = blob;

}

void Runtime1::initialize() {

  // Warning: If we have more than one compilation running in parallel, we

  //          need a lock here with the current setup (lazy initialization).

  if (!is_initialized()) {

    _is_initialized = true;

    // platform-dependent initialization

    initialize_pd();

    // generate stubs

    for (int id = 0; id < number_of_ids; id++) generate_blob_for((StubID)id);

    // printing

#ifndef PRODUCT

    if (PrintSimpleStubs) {

      ResourceMark rm;

      for (int id = 0; id < number_of_ids; id++) {

        _blobs[id]->print();

        if (_blobs[id]->oop_maps() != NULL) {

          _blobs[id]->oop_maps()->print();

        }

      }

    }

#endif

  }

}

CodeBlob* Runtime1::blob_for(StubID id) {

  assert(0 <= id && id < number_of_ids, "illegal stub id");

  if (!is_initialized()) initialize();

  return _blobs[id];

}

const char* Runtime1::name_for(StubID id) {

  assert(0 <= id && id < number_of_ids, "illegal stub id");

  return _blob_names[id];

}

const char* Runtime1::name_for_address(address entry) {

  for (int id = 0; id < number_of_ids; id++) {

    if (entry == entry_for((StubID)id)) return name_for((StubID)id);

  }

#define FUNCTION_CASE(a, f) \

  if ((intptr_t)a == CAST_FROM_FN_PTR(intptr_t, f))  return #f

  FUNCTION_CASE(entry, os::javaTimeMillis);

  FUNCTION_CASE(entry, os::javaTimeNanos);

  FUNCTION_CASE(entry, SharedRuntime::OSR_migration_end);

  FUNCTION_CASE(entry, SharedRuntime::d2f);

  FUNCTION_CASE(entry, SharedRuntime::d2i);

  FUNCTION_CASE(entry, SharedRuntime::d2l);

  FUNCTION_CASE(entry, SharedRuntime::dcos);

  FUNCTION_CASE(entry, SharedRuntime::dexp);

  FUNCTION_CASE(entry, SharedRuntime::dlog);

  FUNCTION_CASE(entry, SharedRuntime::dlog10);

  FUNCTION_CASE(entry, SharedRuntime::dpow);

  FUNCTION_CASE(entry, SharedRuntime::drem);

  FUNCTION_CASE(entry, SharedRuntime::dsin);

  FUNCTION_CASE(entry, SharedRuntime::dtan);

  FUNCTION_CASE(entry, SharedRuntime::f2i);

  FUNCTION_CASE(entry, SharedRuntime::f2l);

  FUNCTION_CASE(entry, SharedRuntime::frem);

  FUNCTION_CASE(entry, SharedRuntime::l2d);

  FUNCTION_CASE(entry, SharedRuntime::l2f);

  FUNCTION_CASE(entry, SharedRuntime::ldiv);

  FUNCTION_CASE(entry, SharedRuntime::lmul);

  FUNCTION_CASE(entry, SharedRuntime::lrem);

  FUNCTION_CASE(entry, SharedRuntime::lrem);

  FUNCTION_CASE(entry, SharedRuntime::dtrace_method_entry);

  FUNCTION_CASE(entry, SharedRuntime::dtrace_method_exit);

  FUNCTION_CASE(entry, trace_block_entry);

#undef FUNCTION_CASE

  return "<unknown function>";

}

JRT_ENTRY(void, Runtime1::new_instance(JavaThread* thread, klassOopDesc* klass))

  NOT_PRODUCT(_new_instance_slowcase_cnt++;)

  assert(oop(klass)->is_klass(), "not a class");

  instanceKlassHandle h(thread, klass);

  h->check_valid_for_instantiation(true, CHECK);

  // make sure klass is initialized

  h->initialize(CHECK);

  // allocate instance and return via TLS

  oop obj = h->allocate_instance(CHECK);

  thread->set_vm_result(obj);

JRT_END

JRT_ENTRY(void, Runtime1::new_type_array(JavaThread* thread, klassOopDesc* klass, jint length))

  NOT_PRODUCT(_new_type_array_slowcase_cnt++;)

  // Note: no handle for klass needed since they are not used

  //       anymore after new_typeArray() and no GC can happen before.

  //       (This may have to change if this code changes!)

  assert(oop(klass)->is_klass(), "not a class");

  BasicType elt_type = typeArrayKlass::cast(klass)->element_type();

  oop obj = oopFactory::new_typeArray(elt_type, length, CHECK);

  thread->set_vm_result(obj);

  // This is pretty rare but this runtime patch is stressful to deoptimization

  // if we deoptimize here so force a deopt to stress the path.

  if (DeoptimizeALot) {

    deopt_caller();

  }

JRT_END

JRT_ENTRY(void, Runtime1::new_object_array(JavaThread* thread, klassOopDesc* array_klass, jint length))

  NOT_PRODUCT(_new_object_array_slowcase_cnt++;)

  // Note: no handle for klass needed since they are not used

  //       anymore after new_objArray() and no GC can happen before.

  //       (This may have to change if this code changes!)

  assert(oop(array_klass)->is_klass(), "not a class");

  klassOop elem_klass = objArrayKlass::cast(array_klass)->element_klass();

  objArrayOop obj = oopFactory::new_objArray(elem_klass, length, CHECK);

  thread->set_vm_result(obj);

  // This is pretty rare but this runtime patch is stressful to deoptimization

  // if we deoptimize here so force a deopt to stress the path.

  if (DeoptimizeALot) {

    deopt_caller();

  }

JRT_END

JRT_ENTRY(void, Runtime1::new_multi_array(JavaThread* thread, klassOopDesc* klass, int rank, jint* dims))

  NOT_PRODUCT(_new_multi_array_slowcase_cnt++;)

  assert(oop(klass)->is_klass(), "not a class");

  assert(rank >= 1, "rank must be nonzero");

#ifdef _LP64

// In 64 bit mode, the sizes are stored in the top 32 bits

// of each 64 bit stack entry.

// dims is actually an intptr_t * because the arguments

// are pushed onto a 64 bit stack.

// We must create an array of jints to pass to multi_allocate.

// We reuse the current stack because it will be popped

// after this bytecode is completed.

  if ( rank > 1 ) {

    int index;

    for ( index = 1; index < rank; index++ ) {  // First size is ok

        dims[index] = dims[index*2];

    }

  }

#endif

  oop obj = arrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);

  thread->set_vm_result(obj);

JRT_END

JRT_ENTRY(void, Runtime1::unimplemented_entry(JavaThread* thread, StubID id))

  tty->print_cr("Runtime1::entry_for(%d) returned unimplemented entry point", id);

JRT_END

JRT_ENTRY(void, Runtime1::throw_array_store_exception(JavaThread* thread))

  THROW(vmSymbolHandles::java_lang_ArrayStoreException());

JRT_END

JRT_ENTRY(void, Runtime1::post_jvmti_exception_throw(JavaThread* thread))

  if (JvmtiExport::can_post_exceptions()) {

    vframeStream vfst(thread, true);

    address bcp = vfst.method()->bcp_from(vfst.bci());

    JvmtiExport::post_exception_throw(thread, vfst.method(), bcp, thread->exception_oop());

  }

JRT_END

#ifdef TIERED

JRT_ENTRY(void, Runtime1::counter_overflow(JavaThread* thread, int bci))

  RegisterMap map(thread, false);

  frame fr =  thread->last_frame().sender(&map);

  nmethod* nm = (nmethod*) fr.cb();

  assert(nm!= NULL && nm->is_nmethod(), "what?");

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

  if (bci == 0) {

    // invocation counter overflow

    if (!Tier1CountOnly) {

      CompilationPolicy::policy()->method_invocation_event(method, CHECK);

    } else {

      method()->invocation_counter()->reset();

    }

  } else {

    if (!Tier1CountOnly) {

      // Twe have a bci but not the destination bci and besides a backedge

      // event is more for OSR which we don't want here.

      CompilationPolicy::policy()->method_invocation_event(method, CHECK);

    } else {

      method()->backedge_counter()->reset();

    }

  }

JRT_END

#endif // TIERED

extern void vm_exit(int code);

// Enter this method from compiled code handler below. This is where we transition

// to VM mode. This is done as a helper routine so that the method called directly

// from compiled code does not have to transition to VM. This allows the entry

// method to see if the nmethod that we have just looked up a handler for has

// been deoptimized while we were in the vm. This simplifies the assembly code

// cpu directories.

//

// We are entering here from exception stub (via the entry method below)

// If there is a compiled exception handler in this method, we will continue there;

// otherwise we will unwind the stack and continue at the caller of top frame method

// Note: we enter in Java using a special JRT wrapper. This wrapper allows us to

// control the area where we can allow a safepoint. After we exit the safepoint area we can

// check to see if the handler we are going to return is now in a nmethod that has

// been deoptimized. If that is the case we return the deopt blob

// unpack_with_exception entry instead. This makes life for the exception blob easier

// because making that same check and diverting is painful from assembly language.

//

JRT_ENTRY_NO_ASYNC(static address, exception_handler_for_pc_helper(JavaThread* thread, oopDesc* ex, address pc, nmethod*& nm))

  Handle exception(thread, ex);

  nm = CodeCache::find_nmethod(pc);

  assert(nm != NULL, "this is not an nmethod");

  // Adjust the pc as needed/

  if (nm->is_deopt_pc(pc)) {

    RegisterMap map(thread, false);

    frame exception_frame = thread->last_frame().sender(&map);

    // if the frame isn't deopted then pc must not correspond to the caller of last_frame

    assert(exception_frame.is_deoptimized_frame(), "must be deopted");

    pc = exception_frame.pc();

  }

#ifdef ASSERT

  assert(exception.not_null(), "NULL exceptions should be handled by throw_exception");

  assert(exception->is_oop(), "just checking");

  // Check that exception is a subclass of Throwable, otherwise we have a VerifyError

  if (!(exception->is_a(SystemDictionary::throwable_klass()))) {

    if (ExitVMOnVerifyError) vm_exit(-1);

    ShouldNotReachHere();

  }

#endif

  // Check the stack guard pages and reenable them if necessary and there is

  // enough space on the stack to do so.  Use fast exceptions only if the guard

  // pages are enabled.

  bool guard_pages_enabled = thread->stack_yellow_zone_enabled();

  if (!guard_pages_enabled) guard_pages_enabled = thread->reguard_stack();

  if (JvmtiExport::can_post_exceptions()) {

    // To ensure correct notification of exception catches and throws

    // we have to deoptimize here.  If we attempted to notify the

    // catches and throws during this exception lookup it's possible

    // we could deoptimize on the way out of the VM and end back in

    // the interpreter at the throw site.  This would result in double

    // notifications since the interpreter would also notify about

    // these same catches and throws as it unwound the frame.

    RegisterMap reg_map(thread);

    frame stub_frame = thread->last_frame();

    frame caller_frame = stub_frame.sender(&reg_map);

    // We don't really want to deoptimize the nmethod itself since we

    // can actually continue in the exception handler ourselves but I

    // don't see an easy way to have the desired effect.

    VM_DeoptimizeFrame deopt(thread, caller_frame.id());

    VMThread::execute(&deopt);

    return SharedRuntime::deopt_blob()->unpack_with_exception_in_tls();

  }

  // ExceptionCache is used only for exceptions at call and not for implicit exceptions

  if (guard_pages_enabled) {

    address fast_continuation = nm->handler_for_exception_and_pc(exception, pc);

    if (fast_continuation != NULL) {

      if (fast_continuation == ExceptionCache::unwind_handler()) fast_continuation = NULL;

      return fast_continuation;

    }

  }

  // If the stack guard pages are enabled, check whether there is a handler in

  // the current method.  Otherwise (guard pages disabled), force an unwind and

  // skip the exception cache update (i.e., just leave continuation==NULL).

  address continuation = NULL;

  if (guard_pages_enabled) {

    // New exception handling mechanism can support inlined methods

    // with exception handlers since the mappings are from PC to PC

    // debugging support

    // tracing

    if (TraceExceptions) {

      ttyLocker ttyl;

      ResourceMark rm;

      tty->print_cr("Exception <%s> (0x%x) thrown in compiled method <%s> at PC " PTR_FORMAT " for thread 0x%x",

                    exception->print_value_string(), (address)exception(), nm->method()->print_value_string(), pc, thread);

    }

    // for AbortVMOnException flag

    NOT_PRODUCT(Exceptions::debug_check_abort(exception));

    // Clear out the exception oop and pc since looking up an

    // exception handler can cause class loading, which might throw an

    // exception and those fields are expected to be clear during

    // normal bytecode execution.

    thread->set_exception_oop(NULL);

    thread->set_exception_pc(NULL);

    continuation = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, false, false);

    // If an exception was thrown during exception dispatch, the exception oop may have changed

    thread->set_exception_oop(exception());

    thread->set_exception_pc(pc);

    // the exception cache is used only by non-implicit exceptions

    if (continuation == NULL) {

      nm->add_handler_for_exception_and_pc(exception, pc, ExceptionCache::unwind_handler());

    } else {

      nm->add_handler_for_exception_and_pc(exception, pc, continuation);

    }

  }

  thread->set_vm_result(exception());

  if (TraceExceptions) {

    ttyLocker ttyl;

    ResourceMark rm;

    tty->print_cr("Thread " PTR_FORMAT " continuing at PC " PTR_FORMAT " for exception thrown at PC " PTR_FORMAT,