truffle: src/cpu/sparc/vm/sharedRuntime

comparison src/cpu/sparc/vm/sharedRuntime_sparc.cpp @ 4970:33df1aeaebbf

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 27 Feb 2012 13:10:13 +0100
parents	931e5f39e365
children	8a48c2906f91

comparison

equal deleted inserted replaced

-:2cfb7fb2dce7
+:33df1aeaebbf
 /*
-* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2012, 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.
 // a frame with no abi restrictions. Since we must observe abi restrictions
 // (like the placement of the register window) the slots must be biased by
 // the following value.
 static int reg2offset(VMReg r) {
 return (r->reg2stack() + SharedRuntime::out_preserve_stack_slots()) * VMRegImpl::stack_slot_size;
+}
+static VMRegPair reg64_to_VMRegPair(Register r) {
+VMRegPair ret;
+if (wordSize == 8) {
+ret.set2(r->as_VMReg());
+} else {
+ret.set_pair(r->successor()->as_VMReg(), r->as_VMReg());
+}
+return ret;
 }
 // ---------------------------------------------------------------------------
 // Read the array of BasicTypes from a signature, and compute where the
 // arguments should go.  Values in the VMRegPair regs array refer to 4-byte (VMRegImpl::stack_slot_size)
 __ mov(src.first()->as_Register(), dst.first()->as_Register());
 }
 }
+static void move_ptr(MacroAssembler* masm, VMRegPair src, VMRegPair dst) {
+if (src.first()->is_stack()) {
+if (dst.first()->is_stack()) {
+// stack to stack
+__ ld_ptr(FP, reg2offset(src.first()) + STACK_BIAS, L5);
+__ st_ptr(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
+} else {
+// stack to reg
+__ ld_ptr(FP, reg2offset(src.first()) + STACK_BIAS, dst.first()->as_Register());
+}
+} else if (dst.first()->is_stack()) {
+// reg to stack
+__ st_ptr(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
+} else {
+__ mov(src.first()->as_Register(), dst.first()->as_Register());
+}
+}
 // An oop arg. Must pass a handle not the oop itself
 static void object_move(MacroAssembler* masm,
 OopMap* map,
 int oop_handle_offset,
 int framesize_in_slots,
 __ mov(G2_thread, L7_thread_cache);
 *already_created = true;
 }
 }
+static void save_or_restore_arguments(MacroAssembler* masm,
+const int stack_slots,
+const int total_in_args,
+const int arg_save_area,
+OopMap* map,
+VMRegPair* in_regs,
+BasicType* in_sig_bt) {
+// if map is non-NULL then the code should store the values,
+// otherwise it should load them.
+if (map != NULL) {
+// Fill in the map
+for (int i = 0; i < total_in_args; i++) {
+if (in_sig_bt[i] == T_ARRAY) {
+if (in_regs[i].first()->is_stack()) {
+int offset_in_older_frame = in_regs[i].first()->reg2stack() + SharedRuntime::out_preserve_stack_slots();
+map->set_oop(VMRegImpl::stack2reg(offset_in_older_frame + stack_slots));
+} else if (in_regs[i].first()->is_Register()) {
+map->set_oop(in_regs[i].first());
+} else {
+ShouldNotReachHere();
+}
+}
+}
+}
+// Save or restore double word values
+int handle_index = 0;
+for (int i = 0; i < total_in_args; i++) {
+int slot = handle_index + arg_save_area;
+int offset = slot * VMRegImpl::stack_slot_size;
+if (in_sig_bt[i] == T_LONG && in_regs[i].first()->is_Register()) {
+const Register reg = in_regs[i].first()->as_Register();
+if (reg->is_global()) {
+handle_index += 2;
+assert(handle_index <= stack_slots, "overflow");
+if (map != NULL) {
+__ stx(reg, SP, offset + STACK_BIAS);
+} else {
+__ ldx(SP, offset + STACK_BIAS, reg);
+}
+}
+} else if (in_sig_bt[i] == T_DOUBLE && in_regs[i].first()->is_FloatRegister()) {
+handle_index += 2;
+assert(handle_index <= stack_slots, "overflow");
+if (map != NULL) {
+__ stf(FloatRegisterImpl::D, in_regs[i].first()->as_FloatRegister(), SP, offset + STACK_BIAS);
+} else {
+__ ldf(FloatRegisterImpl::D, SP, offset + STACK_BIAS, in_regs[i].first()->as_FloatRegister());
+}
+}
+}
+// Save floats
+for (int i = 0; i < total_in_args; i++) {
+int slot = handle_index + arg_save_area;
+int offset = slot * VMRegImpl::stack_slot_size;
+if (in_sig_bt[i] == T_FLOAT && in_regs[i].first()->is_FloatRegister()) {
+handle_index++;
+assert(handle_index <= stack_slots, "overflow");
+if (map != NULL) {
+__ stf(FloatRegisterImpl::S, in_regs[i].first()->as_FloatRegister(), SP, offset + STACK_BIAS);
+} else {
+__ ldf(FloatRegisterImpl::S, SP, offset + STACK_BIAS, in_regs[i].first()->as_FloatRegister());
+}
+}
+}
+}
+// Check GC_locker::needs_gc and enter the runtime if it's true.  This
+// keeps a new JNI critical region from starting until a GC has been
+// forced.  Save down any oops in registers and describe them in an
+// OopMap.
+static void check_needs_gc_for_critical_native(MacroAssembler* masm,
+const int stack_slots,
+const int total_in_args,
+const int arg_save_area,
+OopMapSet* oop_maps,
+VMRegPair* in_regs,
+BasicType* in_sig_bt) {
+__ block_comment("check GC_locker::needs_gc");
+Label cont;
+AddressLiteral sync_state(GC_locker::needs_gc_address());
+__ load_bool_contents(sync_state, G3_scratch);
+__ cmp_zero_and_br(Assembler::equal, G3_scratch, cont);
+__ delayed()->nop();
+// Save down any values that are live in registers and call into the
+// runtime to halt for a GC
+OopMap* map = new OopMap(stack_slots * 2, 0 /* arg_slots*/);
+save_or_restore_arguments(masm, stack_slots, total_in_args,
+arg_save_area, map, in_regs, in_sig_bt);
+__ mov(G2_thread, L7_thread_cache);
+__ set_last_Java_frame(SP, noreg);
+__ block_comment("block_for_jni_critical");
+__ call(CAST_FROM_FN_PTR(address, SharedRuntime::block_for_jni_critical), relocInfo::runtime_call_type);
+__ delayed()->mov(L7_thread_cache, O0);
+oop_maps->add_gc_map( __ offset(), map);
+__ restore_thread(L7_thread_cache); // restore G2_thread
+__ reset_last_Java_frame();
+// Reload all the register arguments
+save_or_restore_arguments(masm, stack_slots, total_in_args,
+arg_save_area, NULL, in_regs, in_sig_bt);
+__ bind(cont);
+#ifdef ASSERT
+if (StressCriticalJNINatives) {
+// Stress register saving
+OopMap* map = new OopMap(stack_slots * 2, 0 /* arg_slots*/);
+save_or_restore_arguments(masm, stack_slots, total_in_args,
+arg_save_area, map, in_regs, in_sig_bt);
+// Destroy argument registers
+for (int i = 0; i < total_in_args; i++) {
+if (in_regs[i].first()->is_Register()) {
+const Register reg = in_regs[i].first()->as_Register();
+if (reg->is_global()) {
+__ mov(G0, reg);
+}
+} else if (in_regs[i].first()->is_FloatRegister()) {
+__ fneg(FloatRegisterImpl::D, in_regs[i].first()->as_FloatRegister(), in_regs[i].first()->as_FloatRegister());
+}
+}
+save_or_restore_arguments(masm, stack_slots, total_in_args,
+arg_save_area, NULL, in_regs, in_sig_bt);
+}
+#endif
+}
+// Unpack an array argument into a pointer to the body and the length
+// if the array is non-null, otherwise pass 0 for both.
+static void unpack_array_argument(MacroAssembler* masm, VMRegPair reg, BasicType in_elem_type, VMRegPair body_arg, VMRegPair length_arg) {
+// Pass the length, ptr pair
+Label is_null, done;
+if (reg.first()->is_stack()) {
+VMRegPair tmp  = reg64_to_VMRegPair(L2);
+// Load the arg up from the stack
+move_ptr(masm, reg, tmp);
+reg = tmp;
+}
+__ cmp(reg.first()->as_Register(), G0);
+__ brx(Assembler::equal, false, Assembler::pt, is_null);
+__ delayed()->add(reg.first()->as_Register(), arrayOopDesc::base_offset_in_bytes(in_elem_type), L4);
+move_ptr(masm, reg64_to_VMRegPair(L4), body_arg);
+__ ld(reg.first()->as_Register(), arrayOopDesc::length_offset_in_bytes(), L4);
+move32_64(masm, reg64_to_VMRegPair(L4), length_arg);
+__ ba_short(done);
+__ bind(is_null);
+// Pass zeros
+move_ptr(masm, reg64_to_VMRegPair(G0), body_arg);
+move32_64(masm, reg64_to_VMRegPair(G0), length_arg);
+__ bind(done);
+}
 // ---------------------------------------------------------------------------
 // Generate a native wrapper for a given method.  The method takes arguments
 // in the Java compiled code convention, marshals them to the native
 // convention (handlizes oops, etc), transitions to native, makes the call,
 // returns to java state (possibly blocking), unhandlizes any result and
 int total_in_args,
 int comp_args_on_stack, // in VMRegStackSlots
 BasicType *in_sig_bt,
 VMRegPair *in_regs,
 BasicType ret_type) {
+bool is_critical_native = true;
+address native_func = method->critical_native_function();
+if (native_func == NULL) {
+native_func = method->native_function();
+is_critical_native = false;
+}
+assert(native_func != NULL, "must have function");
 // Native nmethod wrappers never take possesion of the oop arguments.
 // So the caller will gc the arguments. The only thing we need an
 // oopMap for is if the call is static
 //
 // on entry to the wrapper. We need to convert these args to where
 // the jni function will expect them. To figure out where they go
 // we convert the java signature to a C signature by inserting
 // the hidden arguments as arg[0] and possibly arg[1] (static method)
-int total_c_args = total_in_args + 1;
+int total_c_args = total_in_args;
-if (method->is_static()) {
+int total_save_slots = 6 * VMRegImpl::slots_per_word;
-total_c_args++;
+if (!is_critical_native) {
+total_c_args += 1;
+if (method->is_static()) {
+total_c_args++;
+}
+} else {
+for (int i = 0; i < total_in_args; i++) {
+if (in_sig_bt[i] == T_ARRAY) {
+// These have to be saved and restored across the safepoint
+total_c_args++;
+}
+}
 }
 BasicType* out_sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_c_args);
-VMRegPair  * out_regs   = NEW_RESOURCE_ARRAY(VMRegPair,   total_c_args);
+VMRegPair* out_regs   = NEW_RESOURCE_ARRAY(VMRegPair, total_c_args);
+BasicType* in_elem_bt = NULL;
 int argc = 0;
-out_sig_bt[argc++] = T_ADDRESS;
+if (!is_critical_native) {
-if (method->is_static()) {
+out_sig_bt[argc++] = T_ADDRESS;
-out_sig_bt[argc++] = T_OBJECT;
+if (method->is_static()) {
-}
+out_sig_bt[argc++] = T_OBJECT;
+}
-for (int i = 0; i < total_in_args ; i++ ) {
-out_sig_bt[argc++] = in_sig_bt[i];
+for (int i = 0; i < total_in_args ; i++ ) {
+out_sig_bt[argc++] = in_sig_bt[i];
+}
+} else {
+Thread* THREAD = Thread::current();
+in_elem_bt = NEW_RESOURCE_ARRAY(BasicType, total_in_args);
+SignatureStream ss(method->signature());
+for (int i = 0; i < total_in_args ; i++ ) {
+if (in_sig_bt[i] == T_ARRAY) {
+// Arrays are passed as int, elem* pair
+out_sig_bt[argc++] = T_INT;
+out_sig_bt[argc++] = T_ADDRESS;
+Symbol* atype = ss.as_symbol(CHECK_NULL);
+const char* at = atype->as_C_string();
+if (strlen(at) == 2) {
+assert(at[0] == '[', "must be");
+switch (at[1]) {
+case 'B': in_elem_bt[i]  = T_BYTE; break;
+case 'C': in_elem_bt[i]  = T_CHAR; break;
+case 'D': in_elem_bt[i]  = T_DOUBLE; break;
+case 'F': in_elem_bt[i]  = T_FLOAT; break;
+case 'I': in_elem_bt[i]  = T_INT; break;
+case 'J': in_elem_bt[i]  = T_LONG; break;
+case 'S': in_elem_bt[i]  = T_SHORT; break;
+case 'Z': in_elem_bt[i]  = T_BOOLEAN; break;
+default: ShouldNotReachHere();
+}
+}
+} else {
+out_sig_bt[argc++] = in_sig_bt[i];
+in_elem_bt[i] = T_VOID;
+}
+if (in_sig_bt[i] != T_VOID) {
+assert(in_sig_bt[i] == ss.type(), "must match");
+ss.next();
+}
+}
 }
 // Now figure out where the args must be stored and how much stack space
 // they require (neglecting out_preserve_stack_slots but space for storing
 // the 1st six register arguments). It's weird see int_stk_helper.
 //
 int out_arg_slots;
 out_arg_slots = c_calling_convention(out_sig_bt, out_regs, total_c_args);
+if (is_critical_native) {
+// Critical natives may have to call out so they need a save area
+// for register arguments.
+int double_slots = 0;
+int single_slots = 0;
+for ( int i = 0; i < total_in_args; i++) {
+if (in_regs[i].first()->is_Register()) {
+const Register reg = in_regs[i].first()->as_Register();
+switch (in_sig_bt[i]) {
+case T_ARRAY:
+case T_BOOLEAN:
+case T_BYTE:
+case T_SHORT:
+case T_CHAR:
+case T_INT:  assert(reg->is_in(), "don't need to save these"); break;
+case T_LONG: if (reg->is_global()) double_slots++; break;
+default:  ShouldNotReachHere();
+}
+} else if (in_regs[i].first()->is_FloatRegister()) {
+switch (in_sig_bt[i]) {
+case T_FLOAT:  single_slots++; break;
+case T_DOUBLE: double_slots++; break;
+default:  ShouldNotReachHere();
+}
+}
+}
+total_save_slots = double_slots * 2 + single_slots;
+}
 // Compute framesize for the wrapper.  We need to handlize all oops in
 // registers. We must create space for them here that is disjoint from
 // the windowed save area because we have no control over when we might
 // flush the window again and overwrite values that gc has since modified.
 // First count the abi requirement plus all of the outgoing args
 int stack_slots = SharedRuntime::out_preserve_stack_slots() + out_arg_slots;
 // Now the space for the inbound oop handle area
-int oop_handle_offset = stack_slots;
+int oop_handle_offset = round_to(stack_slots, 2);
-stack_slots += 6*VMRegImpl::slots_per_word;
+stack_slots += total_save_slots;
 // Now any space we need for handlizing a klass if static method
-int oop_temp_slot_offset = 0;
 int klass_slot_offset = 0;
 int klass_offset = -1;
 int lock_slot_offset = 0;
 bool is_static = false;
 int frame_complete = ((intptr_t)__ pc()) - start;
 __ verify_thread();
+if (is_critical_native) {
+check_needs_gc_for_critical_native(masm, stack_slots,  total_in_args,
+oop_handle_offset, oop_maps, in_regs, in_sig_bt);
+}
 //
 // We immediately shuffle the arguments so that any vm call we have to
 // make from here on out (sync slow path, jvmti, etc.) we will have
 // captured the oops from our caller and have a valid oopMap for
 // more args than the caller doubling is enough to make
 // sure we can capture all the incoming oop args from the
 // caller.
 //
 OopMap* map = new OopMap(stack_slots * 2, 0 /* arg_slots*/);
-int c_arg = total_c_args - 1;
 // Record sp-based slot for receiver on stack for non-static methods
 int receiver_offset = -1;
 // We move the arguments backward because the floating point registers
 // destination will always be to a register with a greater or equal register
 freg_destroyed[f] = false;
 }
 #endif /* ASSERT */
-for ( int i = total_in_args - 1; i >= 0 ; i--, c_arg-- ) {
+for ( int i = total_in_args - 1, c_arg = total_c_args - 1; i >= 0 ; i--, c_arg-- ) {
 #ifdef ASSERT
 if (in_regs[i].first()->is_Register()) {
 assert(!reg_destroyed[in_regs[i].first()->as_Register()->encoding()], "ack!");
 } else if (in_regs[i].first()->is_FloatRegister()) {
 }
 #endif /* ASSERT */
 switch (in_sig_bt[i]) {
 case T_ARRAY:
+if (is_critical_native) {
+unpack_array_argument(masm, in_regs[i], in_elem_bt[i], out_regs[c_arg], out_regs[c_arg - 1]);
+c_arg--;
+break;
+}
 case T_OBJECT:
+assert(!is_critical_native, "no oop arguments");
 object_move(masm, map, oop_handle_offset, stack_slots, in_regs[i], out_regs[c_arg],
 ((i == 0) && (!is_static)),
 &receiver_offset);
 break;
 case T_VOID:
 break;
 case T_FLOAT:
 float_move(masm, in_regs[i], out_regs[c_arg]);
 break;
 case T_DOUBLE:
 assert( i + 1 < total_in_args &&
 in_sig_bt[i + 1] == T_VOID &&
 out_sig_bt[c_arg+1] == T_VOID, "bad arg list");
 }
 }
 // Pre-load a static method's oop into O1.  Used both by locking code and
 // the normal JNI call code.
-if (method->is_static()) {
+if (method->is_static() && !is_critical_native) {
 __ set_oop_constant(JNIHandles::make_local(Klass::cast(method->method_holder())->java_mirror()), O1);
 // Now handlize the static class mirror in O1.  It's known not-null.
 __ st_ptr(O1, SP, klass_offset + STACK_BIAS);
 map->set_oop(VMRegImpl::stack2reg(klass_slot_offset));
 const Register L6_handle = L6;
 if (method->is_synchronized()) {
+assert(!is_critical_native, "unhandled");
 __ mov(O1, L6_handle);
 }
 // We have all of the arguments setup at this point. We MUST NOT touch any Oregs
 // except O6/O7. So if we must call out we must push a new frame. We immediately
 // push a new frame and flush the windows.
 #ifdef _LP64
 intptr_t thepc = (intptr_t) __ pc();
 {
 address here = __ pc();
 // Call the next instruction
 __ st_ptr(FP, SP, FP->sp_offset_in_saved_window()*wordSize + STACK_BIAS);
 __ st_ptr(I7, SP, I7->sp_offset_in_saved_window()*wordSize + STACK_BIAS);
 }
 // get JNIEnv* which is first argument to native
+if (!is_critical_native) {
 __ add(G2_thread, in_bytes(JavaThread::jni_environment_offset()), O0);
+}
 // Use that pc we placed in O7 a while back as the current frame anchor
 __ set_last_Java_frame(SP, O7);
+// We flushed the windows ages ago now mark them as flushed before transitioning.
+__ set(JavaFrameAnchor::flushed, G3_scratch);
+__ st(G3_scratch, G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());
 // Transition from _thread_in_Java to _thread_in_native.
 __ set(_thread_in_native, G3_scratch);
-__ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
-// We flushed the windows ages ago now mark them as flushed
-// mark windows as flushed
-__ set(JavaFrameAnchor::flushed, G3_scratch);
-Address flags(G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());
 #ifdef _LP64
-AddressLiteral dest(method->native_function());
+AddressLiteral dest(native_func);
 __ relocate(relocInfo::runtime_call_type);
 __ jumpl_to(dest, O7, O7);
 #else
-__ call(method->native_function(), relocInfo::runtime_call_type);
+__ call(native_func, relocInfo::runtime_call_type);
 #endif
-__ delayed()->st(G3_scratch, flags);
+__ delayed()->st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
 __ restore_thread(L7_thread_cache); // restore G2_thread
 // Unpack native results.  For int-types, we do any needed sign-extension
 // and move things into I0.  The return value there will survive any VM
 break;                      // Cannot de-handlize until after reclaiming jvm_lock
 default:
 ShouldNotReachHere();
 }
+Label after_transition;
 // must we block?
 // Block, if necessary, before resuming in _thread_in_Java state.
 // In order for GC to work, don't clear the last_Java_sp until after blocking.
 { Label no_block;
 // use a leaf call to leave the last_Java_frame setup undisturbed. Doing this
 // lets us share the oopMap we used when we went native rather the create
 // a distinct one for this pc
 //
 save_native_result(masm, ret_type, stack_slots);
-__ call_VM_leaf(L7_thread_cache,
+if (!is_critical_native) {
-CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans),
+__ call_VM_leaf(L7_thread_cache,
-G2_thread);
+CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans),
+G2_thread);
+} else {
+__ call_VM_leaf(L7_thread_cache,
+CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans_and_transition),
+G2_thread);
+}
 // Restore any method result value
 restore_native_result(masm, ret_type, stack_slots);
+if (is_critical_native) {
+// The call above performed the transition to thread_in_Java so
+// skip the transition logic below.
+__ ba(after_transition);
+__ delayed()->nop();
+}
 __ bind(no_block);
 }
 // thread state is thread_in_native_trans. Any safepoint blocking has already
 // happened so we can now change state to _thread_in_Java.
 __ set(_thread_in_Java, G3_scratch);
 __ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
+__ bind(after_transition);
 Label no_reguard;
 __ ld(G2_thread, JavaThread::stack_guard_state_offset(), G3_scratch);
 __ cmp_and_br_short(G3_scratch, JavaThread::stack_guard_yellow_disabled, Assembler::notEqual, Assembler::pt, no_reguard);
 __ mov(G0, I0);
 __ bind(L);
 __ verify_oop(I0);
 }
-// reset handle block
+if (!is_critical_native) {
-__ ld_ptr(G2_thread, in_bytes(JavaThread::active_handles_offset()), L5);
+// reset handle block
-__ st_ptr(G0, L5, JNIHandleBlock::top_offset_in_bytes());
+__ ld_ptr(G2_thread, in_bytes(JavaThread::active_handles_offset()), L5);
+__ st_ptr(G0, L5, JNIHandleBlock::top_offset_in_bytes());
-__ ld_ptr(G2_thread, in_bytes(Thread::pending_exception_offset()), G3_scratch);
-check_forward_pending_exception(masm, G3_scratch);
+__ ld_ptr(G2_thread, in_bytes(Thread::pending_exception_offset()), G3_scratch);
+check_forward_pending_exception(masm, G3_scratch);
+}
 // Return
 #ifndef _LP64
 frame_complete,
 stack_slots / VMRegImpl::slots_per_word,
 (is_static ? in_ByteSize(klass_offset) : in_ByteSize(receiver_offset)),
 in_ByteSize(lock_offset),
 oop_maps);
+if (is_critical_native) {
+nm->set_lazy_critical_native(true);
+}
 return nm;
 }
 #ifdef HAVE_DTRACE_H
 // can use for converting the strings. (256 chars per string in the signature).
 // So any java string larger then this is truncated.
 static int  fp_offset[ConcreteRegisterImpl::number_of_registers] = { 0 };
 static bool offsets_initialized = false;
-static VMRegPair reg64_to_VMRegPair(Register r) {
-VMRegPair ret;
-if (wordSize == 8) {
-ret.set2(r->as_VMReg());
-} else {
-ret.set_pair(r->successor()->as_VMReg(), r->as_VMReg());
-}
-return ret;
-}
 nmethod *SharedRuntime::generate_dtrace_nmethod(
 MacroAssembler *masm, methodHandle method) {
 void SharedRuntime::generate_deopt_blob() {
 // allocate space for the code
 ResourceMark rm;
 // setup code generation tools
 int pad = VerifyThread ? 512 : 0;// Extra slop space for more verify code
+if (UseStackBanging) {
+pad += StackShadowPages*16 + 32;
+}
 #ifdef _LP64
 CodeBuffer buffer("deopt_blob", 2100+pad, 512);
 #else
 // Measured 8/7/03 at 1212 in 32bit debug build (no VerifyThread)
 // Measured 8/7/03 at 1396 in 32bit debug build (VerifyThread)
 void SharedRuntime::generate_uncommon_trap_blob() {
 // allocate space for the code
 ResourceMark rm;
 // setup code generation tools
 int pad = VerifyThread ? 512 : 0;
+if (UseStackBanging) {
+pad += StackShadowPages*16 + 32;
+}
 #ifdef _LP64
 CodeBuffer buffer("uncommon_trap_blob", 2700+pad, 512);
 #else
 // Measured 8/7/03 at 660 in 32bit debug build (no VerifyThread)
 // Measured 8/7/03 at 1028 in 32bit debug build (VerifyThread)

Mercurial > hg > truffle

comparison src/cpu/sparc/vm/sharedRuntime_sparc.cpp @ 4970:33df1aeaebbf