#include "precompiled.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "code/compiledIC.hpp"

#include "code/icBuffer.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "code/scopeDesc.hpp"

#include "code/vtableStubs.hpp"

#include "compiler/compileBroker.hpp"

#include "compiler/compilerOracle.hpp"

#include "compiler/oopMap.hpp"

#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"

#include "gc_implementation/g1/heapRegion.hpp"

#include "gc_interface/collectedHeap.hpp"

#include "interpreter/bytecode.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/linkResolver.hpp"

#include "memory/barrierSet.hpp"

#include "memory/gcLocker.inline.hpp"

#include "memory/oopFactory.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "opto/addnode.hpp"

#include "opto/callnode.hpp"

#include "opto/cfgnode.hpp"

#include "opto/connode.hpp"

#include "opto/graphKit.hpp"

#include "opto/machnode.hpp"

#include "opto/matcher.hpp"

#include "opto/memnode.hpp"

#include "opto/mulnode.hpp"

#include "opto/runtime.hpp"

#include "opto/subnode.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/vframe_hp.hpp"

#include "utilities/copy.hpp"

#include "utilities/preserveException.hpp"

#ifdef TARGET_ARCH_MODEL_x86_32

# include "adfiles/ad_x86_32.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_x86_64

# include "adfiles/ad_x86_64.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_sparc

# include "adfiles/ad_sparc.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_zero

# include "adfiles/ad_zero.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_arm

# include "adfiles/ad_arm.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_ppc

# include "adfiles/ad_ppc.hpp"

#endif

address OptoRuntime::_new_instance_Java = NULL;

address OptoRuntime::_new_array_Java = NULL;

address OptoRuntime::_new_array_nozero_Java = NULL;

address OptoRuntime::_multianewarray2_Java = NULL;

address OptoRuntime::_multianewarray3_Java = NULL;

address OptoRuntime::_multianewarray4_Java = NULL;

address OptoRuntime::_multianewarray5_Java = NULL;

address OptoRuntime::_multianewarrayN_Java = NULL;

address OptoRuntime::_g1_wb_pre_Java = NULL;

address OptoRuntime::_g1_wb_post_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

ExceptionBlob* OptoRuntime::_exception_blob;

#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, _new_array_nozero_Java , new_array_Type , new_array_nozero_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, _multianewarrayN_Java , multianewarrayN_Type , multianewarrayN_C , 0 , true , false, false);

gen(env, _g1_wb_pre_Java , g1_wb_pre_Type , SharedRuntime::g1_wb_pre , 0 , false, false, false);

gen(env, _g1_wb_post_Java , g1_wb_post_Type , SharedRuntime::g1_wb_post , 0 , false, 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

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

}

void OptoRuntime::new_store_pre_barrier(JavaThread* thread) {

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

// we inform the GC that we will be doing initializing writes to

// this object in the future without emitting card-marks, so

// GC may take any compensating steps.

// NOTE: 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");

// GC may decide to give back a safer copy of new_obj.

new_obj = Universe::heap()->new_store_pre_barrier(thread, new_obj);

thread->set_vm_result(new_obj);

}

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

// inform GC that we won't do card marks for initializing writes.

new_store_pre_barrier(thread);

}

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

// inform GC that we won't do card marks for initializing writes.

new_store_pre_barrier(thread);

}

JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_nozero_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;

assert(Klass::cast(array_type)->oop_is_typeArray(), "should be called only for type array");

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

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

result = oopFactory::new_typeArray_nozero(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()) {

// inform GC that we won't do card marks for initializing writes.

new_store_pre_barrier(thread);

}

oop result = thread->vm_result();

if ((len > 0) && (result != NULL) &&

is_deoptimized_caller_frame(thread)) {

// Zero array here if the caller is deoptimized.

int size = ((typeArrayOop)result)->object_size();

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

const size_t hs = arrayOopDesc::header_size(elem_type);

// Align to next 8 bytes to avoid trashing arrays's length.

const size_t aligned_hs = align_object_offset(hs);

HeapWord* obj = (HeapWord*)result;

if (aligned_hs > hs) {

Copy::zero_to_words(obj+hs, aligned_hs-hs);

}

// Optimized zeroing.

Copy::fill_to_aligned_words(obj+aligned_hs, size-aligned_hs);

}

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_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_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_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_ENTRY(void, OptoRuntime::multianewarrayN_C(klassOopDesc* elem_type, arrayOopDesc* dims, JavaThread *thread))

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

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

assert(oop(dims)->is_typeArray(), "not an array");

ResourceMark rm;

jint len = dims->length();

assert(len > 0, "Dimensions array should contain data");

jint *j_dims = typeArrayOop(dims)->int_at_addr(0);

jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);

Copy::conjoint_jints_atomic(j_dims, c_dims, len);

oop obj = arrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);

deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);

thread->set_vm_result(obj);

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::multianewarrayN_Type() {

// create input type (domain)

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

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

fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // array of dim sizes

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::g1_wb_pre_Type() {

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

fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value

fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread

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::g1_wb_post_Type() {

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

fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Card addr

fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // thread

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

// create result type (range)

fields = TypeTuple::fields(0);

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

return TypeFunc::make(domain, range);

}

const TypeFunc *OptoRuntime::uncommon_trap_Type() {

// create input type (domain)

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

// Symbol* 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

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

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

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

}

const TypeFunc* OptoRuntime::void_long_Type() {

// create input type (domain)

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

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

// create result type (range)

fields = TypeTuple::fields(2);

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

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

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

return TypeFunc::make(domain, range);

}

enum ArrayCopyType {

ac_fast, // void(ptr, ptr, size_t)

ac_checkcast, // int(ptr, ptr, size_t, size_t, ptr)

ac_slow, // void(ptr, int, ptr, int, int)

ac_generic // int(ptr, int, ptr, int, int)

};

static const TypeFunc* make_arraycopy_Type(ArrayCopyType act) {

// create input type (domain)

int num_args = (act == ac_fast ? 3 : 5);

int num_size_args = (act == ac_fast ? 1 : act == ac_checkcast ? 2 : 0);

int argcnt = num_args;

LP64_ONLY(argcnt += num_size_args); // halfwords for lengths

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

int argp = TypeFunc::Parms;

fields[argp++] = TypePtr::NOTNULL; // src

if (num_size_args == 0) {

fields[argp++] = TypeInt::INT; // src_pos

}

fields[argp++] = TypePtr::NOTNULL; // dest

if (num_size_args == 0) {

fields[argp++] = TypeInt::INT; // dest_pos

fields[argp++] = TypeInt::INT; // length

}

while (num_size_args-- > 0) {

fields[argp++] = TypeX_X; // size in whatevers (size_t)

LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length

}

if (act == ac_checkcast) {

fields[argp++] = TypePtr::NOTNULL; // super_klass

}

assert(argp == TypeFunc::Parms+argcnt, "correct decoding of act");

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

// create result type if needed

int retcnt = (act == ac_checkcast || act == ac_generic ? 1 : 0);

fields = TypeTuple::fields(1);

if (retcnt == 0)

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

else

fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed

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

return TypeFunc::make(domain, range);

}

const TypeFunc* OptoRuntime::fast_arraycopy_Type() {

// This signature is simple: Two base pointers and a size_t.

return make_arraycopy_Type(ac_fast);

}

const TypeFunc* OptoRuntime::checkcast_arraycopy_Type() {

// An extension of fast_arraycopy_Type which adds type checking.

return make_arraycopy_Type(ac_checkcast);

}

const TypeFunc* OptoRuntime::slow_arraycopy_Type() {

// This signature is exactly the same as System.arraycopy.

// There are no intptr_t (int/long) arguments.

return make_arraycopy_Type(ac_slow);

}

const TypeFunc* OptoRuntime::generic_arraycopy_Type() {

// This signature is like System.arraycopy, except that it returns status.

return make_arraycopy_Type(ac_generic);

}

const TypeFunc* OptoRuntime::array_fill_Type() {

// create input type (domain): pointer, int, size_t

const Type** fields = TypeTuple::fields(3 LP64_ONLY( + 1));

int argp = TypeFunc::Parms;

fields[argp++] = TypePtr::NOTNULL;

fields[argp++] = TypeInt::INT;

fields[argp++] = TypeX_X; // size in whatevers (size_t)

LP64_ONLY(fields[argp++] = Type::HALF); // other half of long length

const TypeTuple *domain = TypeTuple::make(argp, 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::aescrypt_block_Type() {

// create input type (domain)

int num_args = 3;

int argcnt = num_args;

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

int argp = TypeFunc::Parms;

fields[argp++] = TypePtr::NOTNULL; // src

fields[argp++] = TypePtr::NOTNULL; // dest

fields[argp++] = TypePtr::NOTNULL; // k array

assert(argp == TypeFunc::Parms+argcnt, "correct decoding");

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

// no result type needed

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::cipherBlockChaining_aescrypt_Type() {

// create input type (domain)

int num_args = 5;

int argcnt = num_args;

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

int argp = TypeFunc::Parms;

fields[argp++] = TypePtr::NOTNULL; // src

fields[argp++] = TypePtr::NOTNULL; // dest

fields[argp++] = TypePtr::NOTNULL; // k array

fields[argp++] = TypePtr::NOTNULL; // r array

fields[argp++] = TypeInt::INT; // src len

assert(argp == TypeFunc::Parms+argcnt, "correct decoding");

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

// no result type needed

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::osr_end_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // OSR temp buf

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

// create result type

fields = TypeTuple::fields(1);

// fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop

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

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

return TypeFunc::make(domain, range);

}

const TypeFunc* OptoRuntime::profile_receiver_type_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeAryPtr::NOTNULL; // methodData pointer

fields[TypeFunc::Parms+1] = TypeInstPtr::BOTTOM; // receiver oop

const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, 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);

}

JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))

if (receiver == NULL) return;

klassOop receiver_klass = receiver->klass();

intptr_t* mdp = ((intptr_t*)(data)) + DataLayout::header_size_in_cells();

int empty_row = -1; // free row, if any is encountered

// ReceiverTypeData* vc = new ReceiverTypeData(mdp);

for (uint row = 0; row < ReceiverTypeData::row_limit(); row++) {

// if (vc->receiver(row) == receiver_klass)

int receiver_off = ReceiverTypeData::receiver_cell_index(row);

intptr_t row_recv = *(mdp + receiver_off);

if (row_recv == (intptr_t) receiver_klass) {

// vc->set_receiver_count(row, vc->receiver_count(row) + DataLayout::counter_increment);

int count_off = ReceiverTypeData::receiver_count_cell_index(row);

*(mdp + count_off) += DataLayout::counter_increment;

return;

} else if (row_recv == 0) {

// else if (vc->receiver(row) == NULL)

empty_row = (int) row;

}

}

if (empty_row != -1) {

int receiver_off = ReceiverTypeData::receiver_cell_index(empty_row);

// vc->set_receiver(empty_row, receiver_klass);

*(mdp + receiver_off) = (intptr_t) receiver_klass;

// vc->set_receiver_count(empty_row, DataLayout::counter_increment);

int count_off = ReceiverTypeData::receiver_count_cell_index(empty_row);

*(mdp + count_off) = DataLayout::counter_increment;

} else {

// Receiver did not match any saved receiver and there is no empty row for it.

// Increment total counter to indicate polymorphic case.

intptr_t* count_p = (intptr_t*)(((byte*)(data)) + in_bytes(CounterData::count_offset()));

*count_p += DataLayout::counter_increment;

}

bool OptoRuntime::is_callee_saved_register(MachRegisterNumbers reg) {

assert(reg >= 0 && reg < _last_Mach_Reg, "must be a machine register");

switch (register_save_policy[reg]) {

case 'C': return false; //SOC

case 'E': return true ; //SOE

case 'N': return false; //NS

case 'A': return false; //AS

}

ShouldNotReachHere();

return false;

}

static void trace_exception(oop exception_oop, address exception_pc, const char* msg) PRODUCT_RETURN;

JRT_ENTRY_NO_ASYNC(address, OptoRuntime::handle_exception_C_helper(JavaThread* thread, nmethod* &nm))

// Do not confuse exception_oop with pending_exception. The exception_oop

// is only used to pass arguments into the method. Not for general

// exception handling. DO NOT CHANGE IT to use pending_exception, since

// the runtime stubs checks this on exit.

assert(thread->exception_oop() != NULL, "exception oop is found");

address handler_address = NULL;

Handle exception(thread, thread->exception_oop());

if (TraceExceptions) {

trace_exception(exception(), thread->exception_pc(), "");

}

// for AbortVMOnException flag

NOT_PRODUCT(Exceptions::debug_check_abort(exception));

#ifdef ASSERT

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

// should throw an exception here

ShouldNotReachHere();

}

#endif

// new exception handling: this method is entered only from adapters

// exceptions from compiled java methods are handled in compiled code

// using rethrow node

address pc = thread->exception_pc();

nm = CodeCache::find_nmethod(pc);

assert(nm != NULL, "No NMethod found");

if (nm->is_native_method()) {

fatal("Native mathod should not have path to exception handling");

} else {

// we are switching to old paradigm: search for exception handler in caller_frame

// instead in exception handler of caller_frame.sender()

if (JvmtiExport::can_post_on_exceptions()) {

// "Full-speed catching" is not necessary here,

// since we're notifying the VM on every catch.

// Force deoptimization and the rest of the lookup

// will be fine.

deoptimize_caller_frame(thread);

}

// Check the stack guard pages. If enabled, look for handler in this frame;

// otherwise, forcibly unwind the frame.

//

// 4826555: use default current sp for reguard_stack instead of &nm: it's more accurate.

bool force_unwind = !thread->reguard_stack();

bool deopting = false;

if (nm->is_deopt_pc(pc)) {

deopting = true;

RegisterMap map(thread, false);

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

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

// Adjust the pc back to the original throwing pc

pc = deoptee.pc();

}

// If we are forcing an unwind because of stack overflow then deopt is

// irrelevant sice we are throwing the frame away anyway.

if (deopting && !force_unwind) {

handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();

} else {

handler_address =

force_unwind ? NULL : nm->handler_for_exception_and_pc(exception, pc);

if (handler_address == NULL) {

Handle original_exception(thread, exception());

handler_address = SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true);

assert (handler_address != NULL, "must have compiled handler");

// Update the exception cache only when the unwind was not forced

// and there didn't happen another exception during the computation of the

// compiled exception handler.

if (!force_unwind && original_exception() == exception()) {

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

}

} else {

assert(handler_address == SharedRuntime::compute_compiled_exc_handler(nm, pc, exception, force_unwind, true), "Must be the same");

}

}

thread->set_exception_pc(pc);

thread->set_exception_handler_pc(handler_address);

// Check if the exception PC is a MethodHandle call site.

thread->set_is_method_handle_return(nm->is_method_handle_return(pc));

}

// Restore correct return pc. Was saved above.

thread->set_exception_oop(exception());

return handler_address;

address OptoRuntime::handle_exception_C(JavaThread* thread) {

#ifndef PRODUCT

SharedRuntime::_find_handler_ctr++; // find exception handler

#endif

debug_only(NoHandleMark __hm;)

nmethod* nm = NULL;

address handler_address = NULL;

{

// Enter the VM

ResetNoHandleMark rnhm;

handler_address = handle_exception_C_helper(thread, nm);

}

// Back in java: Use no oops, DON'T safepoint

// Now check to see if the handler we are returning is in a now

// deoptimized frame

if (nm != NULL) {

RegisterMap map(thread, false);

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

#ifdef ASSERT

assert(caller.is_compiled_frame(), "must be");

#endif // ASSERT

if (caller.is_deoptimized_frame()) {

handler_address = SharedRuntime::deopt_blob()->unpack_with_exception();

}

}

return handler_address;

}

address OptoRuntime::rethrow_C(oopDesc* exception, JavaThread* thread, address ret_pc) {

#ifndef PRODUCT

SharedRuntime::_rethrow_ctr++; // count rethrows

#endif

assert (exception != NULL, "should have thrown a NULLPointerException");

#ifdef ASSERT

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

// should throw an exception here

ShouldNotReachHere();

}

#endif

thread->set_vm_result(exception);

// Frame not compiled (handles deoptimization blob)

return SharedRuntime::raw_exception_handler_for_return_address(thread, ret_pc);

}

const TypeFunc *OptoRuntime::rethrow_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop

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

// create result type (range)

fields = TypeTuple::fields(1);

fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop

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

return TypeFunc::make(domain, range);

}

void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {

// Deoptimize the caller before continuing, as the compiled

// exception handler table may not be valid.

if (!StressCompiledExceptionHandlers && doit) {

deoptimize_caller_frame(thread);

}

}

void OptoRuntime::deoptimize_caller_frame(JavaThread *thread) {

// Called from within the owner thread, so no need for safepoint

RegisterMap reg_map(thread);

frame stub_frame = thread->last_frame();

assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");

frame caller_frame = stub_frame.sender(&reg_map);

// Deoptimize the caller frame.

Deoptimization::deoptimize_frame(thread, caller_frame.id());

}

bool OptoRuntime::is_deoptimized_caller_frame(JavaThread *thread) {

// Called from within the owner thread, so no need for safepoint

RegisterMap reg_map(thread);

frame stub_frame = thread->last_frame();

assert(stub_frame.is_runtime_frame() || exception_blob()->contains(stub_frame.pc()), "sanity check");

frame caller_frame = stub_frame.sender(&reg_map);

return caller_frame.is_deoptimized_frame();

}

const TypeFunc *OptoRuntime::register_finalizer_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // oop; Receiver

// // The JavaThread* is passed to each routine as the last argument

// fields[TypeFunc::Parms+1] = TypeRawPtr::NOTNULL; // JavaThread *; Executing thread

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::dtrace_method_entry_exit_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage

fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // methodOop; Method we are entering

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::dtrace_object_alloc_Type() {

// create input type (domain)

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

fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage

fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // oop; newly allocated object

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

}

JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))

assert(obj->is_oop(), "must be a valid oop");

assert(obj->klass()->klass_part()->has_finalizer(), "shouldn't be here otherwise");

instanceKlass::register_finalizer(instanceOop(obj), CHECK);

NamedCounter * volatile OptoRuntime::_named_counters = NULL;

void OptoRuntime::print_named_counters() {

int total_lock_count = 0;

int eliminated_lock_count = 0;

NamedCounter* c = _named_counters;

while (c) {

if (c->tag() == NamedCounter::LockCounter || c->tag() == NamedCounter::EliminatedLockCounter) {

int count = c->count();

if (count > 0) {

bool eliminated = c->tag() == NamedCounter::EliminatedLockCounter;

if (Verbose) {

tty->print_cr("%d %s%s", count, c->name(), eliminated ? " (eliminated)" : "");

}

total_lock_count += count;

if (eliminated) {

eliminated_lock_count += count;

}

}

} else if (c->tag() == NamedCounter::BiasedLockingCounter) {

BiasedLockingCounters* blc = ((BiasedLockingNamedCounter*)c)->counters();

if (blc->nonzero()) {

tty->print_cr("%s", c->name());

blc->print_on(tty);

}

}

c = c->next();

}

if (total_lock_count > 0) {

tty->print_cr("dynamic locks: %d", total_lock_count);

if (eliminated_lock_count) {

tty->print_cr("eliminated locks: %d (%d%%)", eliminated_lock_count,

(int)(eliminated_lock_count * 100.0 / total_lock_count));

}

}

}

NamedCounter* OptoRuntime::new_named_counter(JVMState* youngest_jvms, NamedCounter::CounterTag tag) {

int max_depth = youngest_jvms->depth();

// Visit scopes from youngest to oldest.

bool first = true;

stringStream st;

for (int depth = max_depth; depth >= 1; depth--) {

JVMState* jvms = youngest_jvms->of_depth(depth);

ciMethod* m = jvms->has_method() ? jvms->method() : NULL;

if (!first) {

st.print(" ");

} else {

first = false;

}

int bci = jvms->bci();

if (bci < 0) bci = 0;

st.print("%s.%s@%d", m->holder()->name()->as_utf8(), m->name()->as_utf8(), bci);

// To print linenumbers instead of bci use: m->line_number_from_bci(bci)

}

NamedCounter* c;

if (tag == NamedCounter::BiasedLockingCounter) {

c = new BiasedLockingNamedCounter(strdup(st.as_string()));

} else {

c = new NamedCounter(strdup(st.as_string()), tag);

}

// atomically add the new counter to the head of the list. We only

// add counters so this is safe.

NamedCounter* head;

do {

head = _named_counters;

c->set_next(head);

} while (Atomic::cmpxchg_ptr(c, &_named_counters, head) != head);

return c;

}

#ifndef PRODUCT

int trace_exception_counter = 0;

static void trace_exception(oop exception_oop, address exception_pc, const char* msg) {

ttyLocker ttyl;

trace_exception_counter++;

tty->print("%d [Exception (%s): ", trace_exception_counter, msg);

exception_oop->print_value();

tty->print(" in ");

CodeBlob* blob = CodeCache::find_blob(exception_pc);

if (blob->is_nmethod()) {

((nmethod*)blob)->method()->print_value();

} else if (blob->is_runtime_stub()) {

tty->print("<runtime-stub>");

} else {

tty->print("<unknown>");

}

tty->print(" at " INTPTR_FORMAT, exception_pc);

tty->print_cr("]");

}

#endif // PRODUCT

# ifdef ENABLE_ZAP_DEAD_LOCALS

int OptoRuntime::ZapDeadCompiledLocals_count = 0;

static bool is_java_frame( frame* f) { return f->is_java_frame(); }

static bool is_native_frame(frame* f) { return f->is_native_frame(); }

void OptoRuntime::zap_dead_java_or_native_locals(JavaThread* thread,

bool (*is_this_the_right_frame_to_zap)(frame*)) {

assert(JavaThread::current() == thread, "is this needed?");

if ( !ZapDeadCompiledLocals ) return;

bool skip = false;

if ( ZapDeadCompiledLocalsFirst == 0 ) ; // nothing special

else if ( ZapDeadCompiledLocalsFirst > ZapDeadCompiledLocals_count ) skip = true;

else if ( ZapDeadCompiledLocalsFirst == ZapDeadCompiledLocals_count )

warning("starting zapping after skipping");

if ( ZapDeadCompiledLocalsLast == -1 ) ; // nothing special

else if ( ZapDeadCompiledLocalsLast < ZapDeadCompiledLocals_count ) skip = true;

else if ( ZapDeadCompiledLocalsLast == ZapDeadCompiledLocals_count )

warning("about to zap last zap");

++ZapDeadCompiledLocals_count; // counts skipped zaps, too

if ( skip ) return;

// find java frame and zap it

for (StackFrameStream sfs(thread); !sfs.is_done(); sfs.next()) {

if (is_this_the_right_frame_to_zap(sfs.current()) ) {

sfs.current()->zap_dead_locals(thread, sfs.register_map());

return;

}

}

warning("no frame found to zap in zap_dead_Java_locals_C");

}

JRT_LEAF(void, OptoRuntime::zap_dead_Java_locals_C(JavaThread* thread))

zap_dead_java_or_native_locals(thread, is_java_frame);

JRT_LEAF(void, OptoRuntime::zap_dead_native_locals_C(JavaThread* thread))

zap_dead_java_or_native_locals(thread, is_native_frame);

# endif