jdk-sandbox: comparison hotspot/src/cpu/sparc/vm/sharedRuntime

equal deleted inserted replaced

-:9e8daec25638
+:d602ad6538bd
 __ mov(G5_method, L5);
 __ mov(G5_method, O0);         // VM needs target method
 __ mov(I7, O1);                // VM needs caller's callsite
 // Must be a leaf call...
 // can be very far once the blob has been relocated
-Address dest(O7, CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite));
+AddressLiteral dest(CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite));
 __ relocate(relocInfo::runtime_call_type);
-__ jumpl_to(dest, O7);
+__ jumpl_to(dest, O7, O7);
 __ delayed()->mov(G2_thread, L7_thread_cache);
 __ mov(L7_thread_cache, G2_thread);
 __ mov(L1, G1);
 __ mov(L4, G4);
 __ mov(L5, G5_method);
 // Jump to the compiled code just as if compiled code was doing it.
 //
 #ifndef _LP64
 if (g3_crushed) {
 // Rats load was wasted, at least it is in cache...
-__ ld_ptr(G5_method, in_bytes(methodOopDesc::from_compiled_offset()), G3);
+__ ld_ptr(G5_method, methodOopDesc::from_compiled_offset(), G3);
 }
 #endif /* _LP64 */
 // 6243940 We might end up in handle_wrong_method if
 // the callee is deoptimized as we race thru here. If that
 // "compiled" so it is much better to make this transition
 // invisible to the stack walking code. Unfortunately if
 // we try and find the callee by normal means a safepoint
 // is possible. So we stash the desired callee in the thread
 // and the vm will find there should this case occur.
-Address callee_target_addr(G2_thread, 0, in_bytes(JavaThread::callee_target_offset()));
+Address callee_target_addr(G2_thread, JavaThread::callee_target_offset());
 __ st_ptr(G5_method, callee_target_addr);
 if (StressNonEntrant) {
 // Open a big window for deopt failure
 __ save_frame(0);
 Register R_temp   = L0;   // another scratch register
 #else
 Register R_temp   = G1;   // another scratch register
 #endif
-Address ic_miss(G3_scratch, SharedRuntime::get_ic_miss_stub());
+AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
 __ verify_oop(O0);
 __ verify_oop(G5_method);
 __ load_klass(O0, G3_scratch);
 __ verify_oop(G3_scratch);
 #endif
 Label ok, ok2;
 __ brx(Assembler::equal, false, Assembler::pt, ok);
 __ delayed()->ld_ptr(G5_method, compiledICHolderOopDesc::holder_method_offset(), G5_method);
-__ jump_to(ic_miss);
+__ jump_to(ic_miss, G3_scratch);
 __ delayed()->nop();
 __ bind(ok);
 // Method might have been compiled since the call site was patched to
 // interpreted if that is the case treat it as a miss so we can get
 // the call site corrected.
 __ ld_ptr(G5_method, in_bytes(methodOopDesc::code_offset()), G3_scratch);
 __ bind(ok2);
 __ br_null(G3_scratch, false, __ pt, skip_fixup);
 __ delayed()->ld_ptr(G5_method, in_bytes(methodOopDesc::interpreter_entry_offset()), G3_scratch);
-__ jump_to(ic_miss);
+__ jump_to(ic_miss, G3_scratch);
 __ delayed()->nop();
 }
 address c2i_entry = __ pc();
 __ delayed()->mov(L7_thread_cache, G2_thread); // restore in case we have exception
 // Since this is a native call, we *know* the proper exception handler
 // without calling into the VM: it's the empty function.  Just pop this
 // frame and then jump to forward_exception_entry; O7 will contain the
 // native caller's return PC.
-Address exception_entry(G3_scratch, StubRoutines::forward_exception_entry());
+AddressLiteral exception_entry(StubRoutines::forward_exception_entry());
-__ jump_to(exception_entry);
+__ jump_to(exception_entry, G3_scratch);
 __ delayed()->restore();      // Pop this frame off.
 __ bind(L);
 }
 // A simple move of integer like type
 // First thing make an ic check to see if we should even be here
 {
 Label L;
 const Register temp_reg = G3_scratch;
-Address ic_miss(temp_reg, SharedRuntime::get_ic_miss_stub());
+AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
 __ verify_oop(O0);
 __ load_klass(O0, temp_reg);
 __ cmp(temp_reg, G5_inline_cache_reg);
 __ brx(Assembler::equal, true, Assembler::pt, L);
 __ delayed()->nop();
-__ jump_to(ic_miss, 0);
+__ jump_to(ic_miss, temp_reg);
 __ delayed()->nop();
 __ align(CodeEntryAlignment);
 __ bind(L);
 }
 __ set_last_Java_frame(SP, O7);
 // Transition from _thread_in_Java to _thread_in_native.
 __ set(_thread_in_native, G3_scratch);
-__ st(G3_scratch, G2_thread, in_bytes(JavaThread::thread_state_offset()));
+__ 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,
+Address flags(G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());
-0,
-in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::flags_offset()));
 #ifdef _LP64
-Address dest(O7, method->native_function());
+AddressLiteral dest(method->native_function());
 __ relocate(relocInfo::runtime_call_type);
-__ jumpl_to(dest, O7);
+__ jumpl_to(dest, O7, O7);
 #else
 __ call(method->native_function(), relocInfo::runtime_call_type);
 #endif
 __ delayed()->st(G3_scratch, flags);
 // 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;
-Address sync_state(G3_scratch, SafepointSynchronize::address_of_state());
+AddressLiteral sync_state(SafepointSynchronize::address_of_state());
 // Switch thread to "native transition" state before reading the synchronization state.
 // This additional state is necessary because reading and testing the synchronization
 // state is not atomic w.r.t. GC, as this scenario demonstrates:
 //     Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted.
 //     VM thread changes sync state to synchronizing and suspends threads for GC.
 //     Thread A is resumed to finish this native method, but doesn't block here since it
 //     didn't see any synchronization is progress, and escapes.
 __ set(_thread_in_native_trans, G3_scratch);
-__ st(G3_scratch, G2_thread, in_bytes(JavaThread::thread_state_offset()));
+__ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
 if(os::is_MP()) {
 if (UseMembar) {
 // Force this write out before the read below
 __ membar(Assembler::StoreLoad);
 } else {
 }
 __ load_contents(sync_state, G3_scratch);
 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);
 Label L;
-Address suspend_state(G2_thread, 0, in_bytes(JavaThread::suspend_flags_offset()));
+Address suspend_state(G2_thread, JavaThread::suspend_flags_offset());
 __ br(Assembler::notEqual, false, Assembler::pn, L);
-__ delayed()->
+__ delayed()->ld(suspend_state, G3_scratch);
-ld(suspend_state, G3_scratch);
 __ cmp(G3_scratch, 0);
 __ br(Assembler::equal, false, Assembler::pt, no_block);
 __ delayed()->nop();
 __ bind(L);
 // 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, in_bytes(JavaThread::thread_state_offset()));
+__ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
 Label no_reguard;
-__ ld(G2_thread, in_bytes(JavaThread::stack_guard_state_offset()), G3_scratch);
+__ ld(G2_thread, JavaThread::stack_guard_state_offset(), G3_scratch);
 __ cmp(G3_scratch, JavaThread::stack_guard_yellow_disabled);
 __ br(Assembler::notEqual, false, Assembler::pt, no_reguard);
 __ delayed()->nop();
 save_native_result(masm, ret_type, stack_slots);
 // First thing make an ic check to see if we should even be here
 {
 Label L;
 const Register temp_reg = G3_scratch;
-Address ic_miss(temp_reg, SharedRuntime::get_ic_miss_stub());
+AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
 __ verify_oop(O0);
 __ ld_ptr(O0, oopDesc::klass_offset_in_bytes(), temp_reg);
 __ cmp(temp_reg, G5_inline_cache_reg);
 __ brx(Assembler::equal, true, Assembler::pt, L);
 __ delayed()->nop();
-__ jump_to(ic_miss, 0);
+__ jump_to(ic_miss, temp_reg);
 __ delayed()->nop();
 __ align(CodeEntryAlignment);
 __ bind(L);
 }
 // Before we make new frames, check to see if stack is available.
 // Do this after the caller's return address is on top of stack
 if (UseStackBanging) {
 // Get total frame size for interpreted frames
-__ ld(Address(O2UnrollBlock, 0,
+__ ld(O2UnrollBlock, Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes(), O4);
-Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()), O4);
 __ bang_stack_size(O4, O3, G3_scratch);
 }
-__ ld(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::number_of_frames_offset_in_bytes()), O4array_size);
+__ ld(O2UnrollBlock, Deoptimization::UnrollBlock::number_of_frames_offset_in_bytes(), O4array_size);
-__ ld_ptr(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()), G3pcs);
+__ ld_ptr(O2UnrollBlock, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes(), G3pcs);
+__ ld_ptr(O2UnrollBlock, Deoptimization::UnrollBlock::frame_sizes_offset_in_bytes(), O3array);
-__ ld_ptr(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::frame_sizes_offset_in_bytes()), O3array);
 // Adjust old interpreter frame to make space for new frame's extra java locals
 //
 // We capture the original sp for the transition frame only because it is needed in
 // order to properly calculate interpreter_sp_adjustment. Even though in real life
 // be told the sp_adjustment for each frame we create. If the frame size array
 // were to have twice the frame count entries then we could have pairs [sp_adjustment, frame_size]
 // for each frame we create and keep up the illusion every where.
 //
-__ ld(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::caller_adjustment_offset_in_bytes()), O7);
+__ ld(O2UnrollBlock, Deoptimization::UnrollBlock::caller_adjustment_offset_in_bytes(), O7);
 __ mov(SP, O5_savedSP);       // remember initial sender's original sp before adjustment
 __ sub(SP, O7, SP);
 #ifdef ASSERT
 // make sure that there is at least one entry in the array
 Register        O2UnrollBlock      = O2;
 Register        O3tmp              = O3;
 Register        I5exception_tmp    = I5;
 Register        G4exception_tmp    = G4_scratch;
 int             frame_size_words;
-Address         saved_Freturn0_addr(FP, 0, -sizeof(double) + STACK_BIAS);
+Address         saved_Freturn0_addr(FP, -sizeof(double) + STACK_BIAS);
 #if !defined(_LP64) && defined(COMPILER2)
-Address         saved_Greturn1_addr(FP, 0, -sizeof(double) -sizeof(jlong) + STACK_BIAS);
+Address         saved_Greturn1_addr(FP, -sizeof(double) -sizeof(jlong) + STACK_BIAS);
 #endif
 Label           cont;
 OopMapSet *oop_maps = new OopMapSet();
 // state will be extracted normally.
 // save exception oop in JavaThread and fall through into the
 // exception_in_tls case since they are handled in same way except
 // for where the pending exception is kept.
-__ st_ptr(Oexception, G2_thread, in_bytes(JavaThread::exception_oop_offset()));
+__ st_ptr(Oexception, G2_thread, JavaThread::exception_oop_offset());
 //
 // Vanilla deoptimization with an exception pending in exception_oop
 //
 int exception_in_tls_offset = __ offset() - start;
 #ifdef ASSERT
 {
 // verify that there is really an exception oop in exception_oop
 Label has_exception;
-__ ld_ptr(G2_thread, in_bytes(JavaThread::exception_oop_offset()), Oexception);
+__ ld_ptr(G2_thread, JavaThread::exception_oop_offset(), Oexception);
 __ br_notnull(Oexception, false, Assembler::pt, has_exception);
 __ delayed()-> nop();
 __ stop("no exception in thread");
 __ bind(has_exception);
 // verify that there is no pending exception
 Label no_pending_exception;
-Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset()));
+Address exception_addr(G2_thread, Thread::pending_exception_offset());
 __ ld_ptr(exception_addr, Oexception);
 __ br_null(Oexception, false, Assembler::pt, no_pending_exception);
 __ delayed()->nop();
 __ stop("must not have pending exception here");
 __ bind(no_pending_exception);

changeset 2571	d602ad6538bd
parent 2534	08dac9ce0cd7
child 4009	8731c367fa98