/*

 * Copyright 1998-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/_runtime.cpp.incl"

// For debugging purposes:

//  To force FullGCALot inside a runtime function, add the following two lines

//

//  Universe::release_fullgc_alot_dummy();

//  MarkSweep::invoke(0, "Debugging");

//

// At command line specify the parameters: -XX:+FullGCALot -XX:FullGCALotStart=100000000

// Compiled code entry points

address OptoRuntime::_new_instance_Java                           = NULL;

address OptoRuntime::_new_array_Java                              = NULL;

address OptoRuntime::_multianewarray2_Java                        = NULL;

address OptoRuntime::_multianewarray3_Java                        = NULL;

address OptoRuntime::_multianewarray4_Java                        = NULL;

address OptoRuntime::_multianewarray5_Java                        = NULL;

address OptoRuntime::_vtable_must_compile_Java                    = NULL;

address OptoRuntime::_complete_monitor_locking_Java               = NULL;

address OptoRuntime::_rethrow_Java                                = NULL;

address OptoRuntime::_slow_arraycopy_Java                         = NULL;

address OptoRuntime::_register_finalizer_Java                     = NULL;

# ifdef ENABLE_ZAP_DEAD_LOCALS

address OptoRuntime::_zap_dead_Java_locals_Java                   = NULL;

address OptoRuntime::_zap_dead_native_locals_Java                 = NULL;

# endif

// This should be called in an assertion at the start of OptoRuntime routines

// which are entered from compiled code (all of them)

#ifndef PRODUCT

static bool check_compiled_frame(JavaThread* thread) {

  assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");

#ifdef ASSERT

  RegisterMap map(thread, false);

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

  assert(caller.is_compiled_frame(), "not being called from compiled like code");

#endif  /* ASSERT */

  return true;

}

#endif

#define gen(env, var, type_func_gen, c_func, fancy_jump, pass_tls, save_arg_regs, return_pc) \

  var = generate_stub(env, type_func_gen, CAST_FROM_FN_PTR(address, c_func), #var, fancy_jump, pass_tls, save_arg_regs, return_pc)

void OptoRuntime::generate(ciEnv* env) {

  generate_exception_blob();

  // Note: tls: Means fetching the return oop out of the thread-local storage

  //

  //   variable/name                       type-function-gen              , runtime method                  ,fncy_jp, tls,save_args,retpc

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

  gen(env, _new_instance_Java              , new_instance_Type            , new_instance_C                  ,    0 , true , false, false);

  gen(env, _new_array_Java                 , new_array_Type               , new_array_C                     ,    0 , true , false, false);

  gen(env, _multianewarray2_Java           , multianewarray2_Type         , multianewarray2_C               ,    0 , true , false, false);

  gen(env, _multianewarray3_Java           , multianewarray3_Type         , multianewarray3_C               ,    0 , true , false, false);

  gen(env, _multianewarray4_Java           , multianewarray4_Type         , multianewarray4_C               ,    0 , true , false, false);

  gen(env, _multianewarray5_Java           , multianewarray5_Type         , multianewarray5_C               ,    0 , true , false, false);

  gen(env, _complete_monitor_locking_Java  , complete_monitor_enter_Type  , SharedRuntime::complete_monitor_locking_C      ,    0 , false, false, false);

  gen(env, _rethrow_Java                   , rethrow_Type                 , rethrow_C                       ,    2 , true , false, true );

  gen(env, _slow_arraycopy_Java            , slow_arraycopy_Type          , SharedRuntime::slow_arraycopy_C ,    0 , false, false, false);

  gen(env, _register_finalizer_Java        , register_finalizer_Type      , register_finalizer              ,    0 , false, false, false);

# ifdef ENABLE_ZAP_DEAD_LOCALS

  gen(env, _zap_dead_Java_locals_Java      , zap_dead_locals_Type         , zap_dead_Java_locals_C          ,    0 , false, true , false );

  gen(env, _zap_dead_native_locals_Java    , zap_dead_locals_Type         , zap_dead_native_locals_C        ,    0 , false, true , false );

# endif

}

#undef gen

// Helper method to do generation of RunTimeStub's

address OptoRuntime::generate_stub( ciEnv* env,

                                    TypeFunc_generator gen, address C_function,

                                    const char *name, int is_fancy_jump,

                                    bool pass_tls,

                                    bool save_argument_registers,

                                    bool return_pc ) {

  ResourceMark rm;

  Compile C( env, gen, C_function, name, is_fancy_jump, pass_tls, save_argument_registers, return_pc );

  return  C.stub_entry_point();

}

const char* OptoRuntime::stub_name(address entry) {

#ifndef PRODUCT

  CodeBlob* cb = CodeCache::find_blob(entry);

  RuntimeStub* rs =(RuntimeStub *)cb;

  assert(rs != NULL && rs->is_runtime_stub(), "not a runtime stub");

  return rs->name();

#else

  // Fast implementation for product mode (maybe it should be inlined too)

  return "runtime stub";

#endif

}

//=============================================================================

// Opto compiler runtime routines

//=============================================================================

//=============================allocation======================================

// We failed the fast-path allocation.  Now we need to do a scavenge or GC

// and try allocation again.

void OptoRuntime::do_eager_card_mark(JavaThread* thread) {

  // After any safepoint, just before going back to compiled code,

  // we perform a card mark.  This lets the compiled code omit

  // card marks for initialization of new objects.

  // Keep this code consistent with GraphKit::store_barrier.

  oop new_obj = thread->vm_result();

  if (new_obj == NULL)  return;

  assert(Universe::heap()->can_elide_tlab_store_barriers(),

         "compiler must check this first");

  new_obj = Universe::heap()->new_store_barrier(new_obj);

  thread->set_vm_result(new_obj);

}

// object allocation

JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(klassOopDesc* klass, JavaThread* thread))

  JRT_BLOCK;

#ifndef PRODUCT

  SharedRuntime::_new_instance_ctr++;         // new instance requires GC

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

  // These checks are cheap to make and support reflective allocation.

  int lh = Klass::cast(klass)->layout_helper();

  if (Klass::layout_helper_needs_slow_path(lh)

      || !instanceKlass::cast(klass)->is_initialized()) {

    KlassHandle kh(THREAD, klass);

    kh->check_valid_for_instantiation(false, THREAD);

    if (!HAS_PENDING_EXCEPTION) {

      instanceKlass::cast(kh())->initialize(THREAD);

    }

    if (!HAS_PENDING_EXCEPTION) {

      klass = kh();

    } else {

      klass = NULL;

    }

  }

  if (klass != NULL) {

    // Scavenge and allocate an instance.

    oop result = instanceKlass::cast(klass)->allocate_instance(THREAD);

    thread->set_vm_result(result);

    // Pass oops back through thread local storage.  Our apparent type to Java

    // is that we return an oop, but we can block on exit from this routine and

    // a GC can trash the oop in C's return register.  The generated stub will

    // fetch the oop from TLS after any possible GC.

  }

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  JRT_BLOCK_END;

  if (GraphKit::use_ReduceInitialCardMarks()) {

    // do them now so we don't have to do them on the fast path

    do_eager_card_mark(thread);

  }

JRT_END

// array allocation

JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_C(klassOopDesc* array_type, int len, JavaThread *thread))

  JRT_BLOCK;

#ifndef PRODUCT

  SharedRuntime::_new_array_ctr++;            // new array requires GC

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

  // Scavenge and allocate an instance.

  oop result;

  if (Klass::cast(array_type)->oop_is_typeArray()) {

    // The oopFactory likes to work with the element type.

    // (We could bypass the oopFactory, since it doesn't add much value.)

    BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();

    result = oopFactory::new_typeArray(elem_type, len, THREAD);

  } else {

    // Although the oopFactory likes to work with the elem_type,

    // the compiler prefers the array_type, since it must already have

    // that latter value in hand for the fast path.

    klassOopDesc* elem_type = objArrayKlass::cast(array_type)->element_klass();

    result = oopFactory::new_objArray(elem_type, len, THREAD);

  }

  // Pass oops back through thread local storage.  Our apparent type to Java

  // is that we return an oop, but we can block on exit from this routine and

  // a GC can trash the oop in C's return register.  The generated stub will

  // fetch the oop from TLS after any possible GC.

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  thread->set_vm_result(result);

  JRT_BLOCK_END;

  if (GraphKit::use_ReduceInitialCardMarks()) {

    // do them now so we don't have to do them on the fast path

    do_eager_card_mark(thread);

  }

JRT_END

// Note: multianewarray for one dimension is handled inline by GraphKit::new_array.

// multianewarray for 2 dimensions

JRT_ENTRY(void, OptoRuntime::multianewarray2_C(klassOopDesc* elem_type, int len1, int len2, JavaThread *thread))

#ifndef PRODUCT

  SharedRuntime::_multi2_ctr++;                // multianewarray for 1 dimension

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

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

  jint dims[2];

  dims[0] = len1;

  dims[1] = len2;

  oop obj = arrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  thread->set_vm_result(obj);

JRT_END

// multianewarray for 3 dimensions

JRT_ENTRY(void, OptoRuntime::multianewarray3_C(klassOopDesc* elem_type, int len1, int len2, int len3, JavaThread *thread))

#ifndef PRODUCT

  SharedRuntime::_multi3_ctr++;                // multianewarray for 1 dimension

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

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

  jint dims[3];

  dims[0] = len1;

  dims[1] = len2;

  dims[2] = len3;

  oop obj = arrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  thread->set_vm_result(obj);

JRT_END

// multianewarray for 4 dimensions

JRT_ENTRY(void, OptoRuntime::multianewarray4_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, JavaThread *thread))

#ifndef PRODUCT

  SharedRuntime::_multi4_ctr++;                // multianewarray for 1 dimension

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

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

  jint dims[4];

  dims[0] = len1;

  dims[1] = len2;

  dims[2] = len3;

  dims[3] = len4;

  oop obj = arrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  thread->set_vm_result(obj);

JRT_END

// multianewarray for 5 dimensions

JRT_ENTRY(void, OptoRuntime::multianewarray5_C(klassOopDesc* elem_type, int len1, int len2, int len3, int len4, int len5, JavaThread *thread))

#ifndef PRODUCT

  SharedRuntime::_multi5_ctr++;                // multianewarray for 1 dimension

#endif

  assert(check_compiled_frame(thread), "incorrect caller");

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

  jint dims[5];

  dims[0] = len1;

  dims[1] = len2;

  dims[2] = len3;

  dims[3] = len4;

  dims[4] = len5;

  oop obj = arrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);

  deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

  thread->set_vm_result(obj);

JRT_END

const TypeFunc *OptoRuntime::new_instance_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);

  // create result type (range)

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::athrow_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);

  // create result type (range)

  fields = TypeTuple::fields(0);

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::new_array_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;   // element klass

  fields[TypeFunc::Parms+1] = TypeInt::INT;       // array size

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);

  // create result type (range)

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {

  // create input type (domain)

  const int nargs = ndim + 1;

  const Type **fields = TypeTuple::fields(nargs);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;   // element klass

  for( int i = 1; i < nargs; i++ )

    fields[TypeFunc::Parms + i] = TypeInt::INT;       // array size

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+nargs, fields);

  // create result type (range)

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::multianewarray2_Type() {

  return multianewarray_Type(2);

}

const TypeFunc *OptoRuntime::multianewarray3_Type() {

  return multianewarray_Type(3);

}

const TypeFunc *OptoRuntime::multianewarray4_Type() {

  return multianewarray_Type(4);

}

const TypeFunc *OptoRuntime::multianewarray5_Type() {

  return multianewarray_Type(5);

}

const TypeFunc *OptoRuntime::uncommon_trap_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(1);

  // symbolOop name of class to be loaded

  fields[TypeFunc::Parms+0] = TypeInt::INT;

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);

  // create result type (range)

  fields = TypeTuple::fields(0);

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);

  return TypeFunc::make(domain, range);

}

# ifdef ENABLE_ZAP_DEAD_LOCALS

// Type used for stub generation for zap_dead_locals.

// No inputs or outputs

const TypeFunc *OptoRuntime::zap_dead_locals_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(0);

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms,fields);

  // create result type (range)

  fields = TypeTuple::fields(0);

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms,fields);

  return TypeFunc::make(domain,range);

}

# endif

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

// Monitor Handling

const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked

  fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;   // Address of stack location for lock

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);

  // create result type (range)

  fields = TypeTuple::fields(0);

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);

  return TypeFunc::make(domain,range);

}

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

const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;  // Object to be Locked

  fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;   // Address of stack location for lock

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);

  // create result type (range)

  fields = TypeTuple::fields(0);

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);

  return TypeFunc::make(domain,range);

}

const TypeFunc* OptoRuntime::flush_windows_Type() {

  // create input type (domain)

  const Type** fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = NULL; // void

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms, fields);

  // create result type

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = NULL; // void

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc* OptoRuntime::l2f_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = TypeLong::LONG;

  fields[TypeFunc::Parms+1] = Type::HALF;

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);

  // create result type (range)

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = Type::FLOAT;

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc* OptoRuntime::modf_Type() {

  const Type **fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = Type::FLOAT;

  fields[TypeFunc::Parms+1] = Type::FLOAT;

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);

  // create result type (range)

  fields = TypeTuple::fields(1);

  fields[TypeFunc::Parms+0] = Type::FLOAT;

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::Math_D_D_Type() {

  // create input type (domain)

  const Type **fields = TypeTuple::fields(2);

  // symbolOop name of class to be loaded

  fields[TypeFunc::Parms+0] = Type::DOUBLE;

  fields[TypeFunc::Parms+1] = Type::HALF;

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);

  // create result type (range)

  fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = Type::DOUBLE;

  fields[TypeFunc::Parms+1] = Type::HALF;

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);

  return TypeFunc::make(domain, range);

}

const TypeFunc* OptoRuntime::Math_DD_D_Type() {

  const Type **fields = TypeTuple::fields(4);

  fields[TypeFunc::Parms+0] = Type::DOUBLE;

  fields[TypeFunc::Parms+1] = Type::HALF;

  fields[TypeFunc::Parms+2] = Type::DOUBLE;

  fields[TypeFunc::Parms+3] = Type::HALF;

  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+4, fields);

  // create result type (range)

  fields = TypeTuple::fields(2);

  fields[TypeFunc::Parms+0] = Type::DOUBLE;

  fields[TypeFunc::Parms+1] = Type::HALF;

  const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);

  return TypeFunc::make(domain, range);