Mercurial > hg > graal-jvmci-8

comparison src/cpu/sparc/vm/sharedRuntime_sparc.cpp @ 727:6b2273dd6fa9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6822110: Add AddressLiteral class on SPARC Summary: The Address class on SPARC currently handles both, addresses and address literals, what makes the Address class more complicated than it has to be. Reviewed-by: never, kvn
author twisti
date Tue, 21 Apr 2009 11:16:30 -0700
parents e5b0439ef4ae
children dcf03e02b020
comparison
equal deleted inserted replaced
725:928912ce8438 727:6b2273dd6fa9
623 __ mov(G5_method, L5); 623 __ mov(G5_method, L5);
624 __ mov(G5_method, O0); // VM needs target method 624 __ mov(G5_method, O0); // VM needs target method
625 __ mov(I7, O1); // VM needs caller's callsite 625 __ mov(I7, O1); // VM needs caller's callsite
626 // Must be a leaf call... 626 // Must be a leaf call...
627 // can be very far once the blob has been relocated 627 // can be very far once the blob has been relocated
628 Address dest(O7, CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite)); 628 AddressLiteral dest(CAST_FROM_FN_PTR(address, SharedRuntime::fixup_callers_callsite));
629 __ relocate(relocInfo::runtime_call_type); 629 __ relocate(relocInfo::runtime_call_type);
630 __ jumpl_to(dest, O7); 630 __ jumpl_to(dest, O7, O7);
631 __ delayed()->mov(G2_thread, L7_thread_cache); 631 __ delayed()->mov(G2_thread, L7_thread_cache);
632 __ mov(L7_thread_cache, G2_thread); 632 __ mov(L7_thread_cache, G2_thread);
633 __ mov(L1, G1); 633 __ mov(L1, G1);
634 __ mov(L4, G4); 634 __ mov(L4, G4);
635 __ mov(L5, G5_method); 635 __ mov(L5, G5_method);
1150 // Jump to the compiled code just as if compiled code was doing it. 1150 // Jump to the compiled code just as if compiled code was doing it.
1151 // 1151 //
1152 #ifndef _LP64 1152 #ifndef _LP64
1153 if (g3_crushed) { 1153 if (g3_crushed) {
1154 // Rats load was wasted, at least it is in cache... 1154 // Rats load was wasted, at least it is in cache...
1155 __ ld_ptr(G5_method, in_bytes(methodOopDesc::from_compiled_offset()), G3); 1155 __ ld_ptr(G5_method, methodOopDesc::from_compiled_offset(), G3);
1156 } 1156 }
1157 #endif /* _LP64 */ 1157 #endif /* _LP64 */
1158 1158
1159 // 6243940 We might end up in handle_wrong_method if 1159 // 6243940 We might end up in handle_wrong_method if
1160 // the callee is deoptimized as we race thru here. If that 1160 // the callee is deoptimized as we race thru here. If that
1163 // "compiled" so it is much better to make this transition 1163 // "compiled" so it is much better to make this transition
1164 // invisible to the stack walking code. Unfortunately if 1164 // invisible to the stack walking code. Unfortunately if
1165 // we try and find the callee by normal means a safepoint 1165 // we try and find the callee by normal means a safepoint
1166 // is possible. So we stash the desired callee in the thread 1166 // is possible. So we stash the desired callee in the thread
1167 // and the vm will find there should this case occur. 1167 // and the vm will find there should this case occur.
1168 Address callee_target_addr(G2_thread, 0, in_bytes(JavaThread::callee_target_offset())); 1168 Address callee_target_addr(G2_thread, JavaThread::callee_target_offset());
1169 __ st_ptr(G5_method, callee_target_addr); 1169 __ st_ptr(G5_method, callee_target_addr);
1170 1170
1171 if (StressNonEntrant) { 1171 if (StressNonEntrant) {
1172 // Open a big window for deopt failure 1172 // Open a big window for deopt failure
1173 __ save_frame(0); 1173 __ save_frame(0);
1216 Register R_temp = L0; // another scratch register 1216 Register R_temp = L0; // another scratch register
1217 #else 1217 #else
1218 Register R_temp = G1; // another scratch register 1218 Register R_temp = G1; // another scratch register
1219 #endif 1219 #endif
1220 1220
1221 Address ic_miss(G3_scratch, SharedRuntime::get_ic_miss_stub()); 1221 AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
1222 1222
1223 __ verify_oop(O0); 1223 __ verify_oop(O0);
1224 __ verify_oop(G5_method); 1224 __ verify_oop(G5_method);
1225 __ load_klass(O0, G3_scratch); 1225 __ load_klass(O0, G3_scratch);
1226 __ verify_oop(G3_scratch); 1226 __ verify_oop(G3_scratch);
1238 #endif 1238 #endif
1239 1239
1240 Label ok, ok2; 1240 Label ok, ok2;
1241 __ brx(Assembler::equal, false, Assembler::pt, ok); 1241 __ brx(Assembler::equal, false, Assembler::pt, ok);
1242 __ delayed()->ld_ptr(G5_method, compiledICHolderOopDesc::holder_method_offset(), G5_method); 1242 __ delayed()->ld_ptr(G5_method, compiledICHolderOopDesc::holder_method_offset(), G5_method);
1243 __ jump_to(ic_miss); 1243 __ jump_to(ic_miss, G3_scratch);
1244 __ delayed()->nop(); 1244 __ delayed()->nop();
1245 1245
1246 __ bind(ok); 1246 __ bind(ok);
1247 // Method might have been compiled since the call site was patched to 1247 // Method might have been compiled since the call site was patched to
1248 // interpreted if that is the case treat it as a miss so we can get 1248 // interpreted if that is the case treat it as a miss so we can get
1249 // the call site corrected. 1249 // the call site corrected.
1250 __ ld_ptr(G5_method, in_bytes(methodOopDesc::code_offset()), G3_scratch); 1250 __ ld_ptr(G5_method, in_bytes(methodOopDesc::code_offset()), G3_scratch);
1251 __ bind(ok2); 1251 __ bind(ok2);
1252 __ br_null(G3_scratch, false, __ pt, skip_fixup); 1252 __ br_null(G3_scratch, false, __ pt, skip_fixup);
1253 __ delayed()->ld_ptr(G5_method, in_bytes(methodOopDesc::interpreter_entry_offset()), G3_scratch); 1253 __ delayed()->ld_ptr(G5_method, in_bytes(methodOopDesc::interpreter_entry_offset()), G3_scratch);
1254 __ jump_to(ic_miss); 1254 __ jump_to(ic_miss, G3_scratch);
1255 __ delayed()->nop(); 1255 __ delayed()->nop();
1256 1256
1257 } 1257 }
1258 1258
1259 address c2i_entry = __ pc(); 1259 address c2i_entry = __ pc();
1442 __ delayed()->mov(L7_thread_cache, G2_thread); // restore in case we have exception 1442 __ delayed()->mov(L7_thread_cache, G2_thread); // restore in case we have exception
1443 // Since this is a native call, we *know* the proper exception handler 1443 // Since this is a native call, we *know* the proper exception handler
1444 // without calling into the VM: it's the empty function. Just pop this 1444 // without calling into the VM: it's the empty function. Just pop this
1445 // frame and then jump to forward_exception_entry; O7 will contain the 1445 // frame and then jump to forward_exception_entry; O7 will contain the
1446 // native caller's return PC. 1446 // native caller's return PC.
1447 Address exception_entry(G3_scratch, StubRoutines::forward_exception_entry()); 1447 AddressLiteral exception_entry(StubRoutines::forward_exception_entry());
1448 __ jump_to(exception_entry); 1448 __ jump_to(exception_entry, G3_scratch);
1449 __ delayed()->restore(); // Pop this frame off. 1449 __ delayed()->restore(); // Pop this frame off.
1450 __ bind(L); 1450 __ bind(L);
1451 } 1451 }
1452 1452
1453 // A simple move of integer like type 1453 // A simple move of integer like type
1820 1820
1821 // First thing make an ic check to see if we should even be here 1821 // First thing make an ic check to see if we should even be here
1822 { 1822 {
1823 Label L; 1823 Label L;
1824 const Register temp_reg = G3_scratch; 1824 const Register temp_reg = G3_scratch;
1825 Address ic_miss(temp_reg, SharedRuntime::get_ic_miss_stub()); 1825 AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
1826 __ verify_oop(O0); 1826 __ verify_oop(O0);
1827 __ load_klass(O0, temp_reg); 1827 __ load_klass(O0, temp_reg);
1828 __ cmp(temp_reg, G5_inline_cache_reg); 1828 __ cmp(temp_reg, G5_inline_cache_reg);
1829 __ brx(Assembler::equal, true, Assembler::pt, L); 1829 __ brx(Assembler::equal, true, Assembler::pt, L);
1830 __ delayed()->nop(); 1830 __ delayed()->nop();
1831 1831
1832 __ jump_to(ic_miss, 0); 1832 __ jump_to(ic_miss, temp_reg);
1833 __ delayed()->nop(); 1833 __ delayed()->nop();
1834 __ align(CodeEntryAlignment); 1834 __ align(CodeEntryAlignment);
1835 __ bind(L); 1835 __ bind(L);
1836 } 1836 }
1837 1837
2259 2259
2260 __ set_last_Java_frame(SP, O7); 2260 __ set_last_Java_frame(SP, O7);
2261 2261
2262 // Transition from _thread_in_Java to _thread_in_native. 2262 // Transition from _thread_in_Java to _thread_in_native.
2263 __ set(_thread_in_native, G3_scratch); 2263 __ set(_thread_in_native, G3_scratch);
2264 __ st(G3_scratch, G2_thread, in_bytes(JavaThread::thread_state_offset())); 2264 __ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
2265 2265
2266 // We flushed the windows ages ago now mark them as flushed 2266 // We flushed the windows ages ago now mark them as flushed
2267 2267
2268 // mark windows as flushed 2268 // mark windows as flushed
2269 __ set(JavaFrameAnchor::flushed, G3_scratch); 2269 __ set(JavaFrameAnchor::flushed, G3_scratch);
2270 2270
2271 Address flags(G2_thread, 2271 Address flags(G2_thread, JavaThread::frame_anchor_offset() + JavaFrameAnchor::flags_offset());
2272 0,
2273 in_bytes(JavaThread::frame_anchor_offset()) + in_bytes(JavaFrameAnchor::flags_offset()));
2274 2272
2275 #ifdef _LP64 2273 #ifdef _LP64
2276 Address dest(O7, method->native_function()); 2274 AddressLiteral dest(method->native_function());
2277 __ relocate(relocInfo::runtime_call_type); 2275 __ relocate(relocInfo::runtime_call_type);
2278 __ jumpl_to(dest, O7); 2276 __ jumpl_to(dest, O7, O7);
2279 #else 2277 #else
2280 __ call(method->native_function(), relocInfo::runtime_call_type); 2278 __ call(method->native_function(), relocInfo::runtime_call_type);
2281 #endif 2279 #endif
2282 __ delayed()->st(G3_scratch, flags); 2280 __ delayed()->st(G3_scratch, flags);
2283 2281
2314 // must we block? 2312 // must we block?
2315 2313
2316 // Block, if necessary, before resuming in _thread_in_Java state. 2314 // Block, if necessary, before resuming in _thread_in_Java state.
2317 // In order for GC to work, don't clear the last_Java_sp until after blocking. 2315 // In order for GC to work, don't clear the last_Java_sp until after blocking.
2318 { Label no_block; 2316 { Label no_block;
2319 Address sync_state(G3_scratch, SafepointSynchronize::address_of_state()); 2317 AddressLiteral sync_state(SafepointSynchronize::address_of_state());
2320 2318
2321 // Switch thread to "native transition" state before reading the synchronization state. 2319 // Switch thread to "native transition" state before reading the synchronization state.
2322 // This additional state is necessary because reading and testing the synchronization 2320 // This additional state is necessary because reading and testing the synchronization
2323 // state is not atomic w.r.t. GC, as this scenario demonstrates: 2321 // state is not atomic w.r.t. GC, as this scenario demonstrates:
2324 // Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted. 2322 // Java thread A, in _thread_in_native state, loads _not_synchronized and is preempted.
2325 // VM thread changes sync state to synchronizing and suspends threads for GC. 2323 // VM thread changes sync state to synchronizing and suspends threads for GC.
2326 // Thread A is resumed to finish this native method, but doesn't block here since it 2324 // Thread A is resumed to finish this native method, but doesn't block here since it
2327 // didn't see any synchronization is progress, and escapes. 2325 // didn't see any synchronization is progress, and escapes.
2328 __ set(_thread_in_native_trans, G3_scratch); 2326 __ set(_thread_in_native_trans, G3_scratch);
2329 __ st(G3_scratch, G2_thread, in_bytes(JavaThread::thread_state_offset())); 2327 __ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
2330 if(os::is_MP()) { 2328 if(os::is_MP()) {
2331 if (UseMembar) { 2329 if (UseMembar) {
2332 // Force this write out before the read below 2330 // Force this write out before the read below
2333 __ membar(Assembler::StoreLoad); 2331 __ membar(Assembler::StoreLoad);
2334 } else { 2332 } else {
2341 } 2339 }
2342 __ load_contents(sync_state, G3_scratch); 2340 __ load_contents(sync_state, G3_scratch);
2343 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized); 2341 __ cmp(G3_scratch, SafepointSynchronize::_not_synchronized);
2344 2342
2345 Label L; 2343 Label L;
2346 Address suspend_state(G2_thread, 0, in_bytes(JavaThread::suspend_flags_offset())); 2344 Address suspend_state(G2_thread, JavaThread::suspend_flags_offset());
2347 __ br(Assembler::notEqual, false, Assembler::pn, L); 2345 __ br(Assembler::notEqual, false, Assembler::pn, L);
2348 __ delayed()-> 2346 __ delayed()->ld(suspend_state, G3_scratch);
2349 ld(suspend_state, G3_scratch);
2350 __ cmp(G3_scratch, 0); 2347 __ cmp(G3_scratch, 0);
2351 __ br(Assembler::equal, false, Assembler::pt, no_block); 2348 __ br(Assembler::equal, false, Assembler::pt, no_block);
2352 __ delayed()->nop(); 2349 __ delayed()->nop();
2353 __ bind(L); 2350 __ bind(L);
2354 2351
2370 // thread state is thread_in_native_trans. Any safepoint blocking has already 2367 // thread state is thread_in_native_trans. Any safepoint blocking has already
2371 // happened so we can now change state to _thread_in_Java. 2368 // happened so we can now change state to _thread_in_Java.
2372 2369
2373 2370
2374 __ set(_thread_in_Java, G3_scratch); 2371 __ set(_thread_in_Java, G3_scratch);
2375 __ st(G3_scratch, G2_thread, in_bytes(JavaThread::thread_state_offset())); 2372 __ st(G3_scratch, G2_thread, JavaThread::thread_state_offset());
2376 2373
2377 2374
2378 Label no_reguard; 2375 Label no_reguard;
2379 __ ld(G2_thread, in_bytes(JavaThread::stack_guard_state_offset()), G3_scratch); 2376 __ ld(G2_thread, JavaThread::stack_guard_state_offset(), G3_scratch);
2380 __ cmp(G3_scratch, JavaThread::stack_guard_yellow_disabled); 2377 __ cmp(G3_scratch, JavaThread::stack_guard_yellow_disabled);
2381 __ br(Assembler::notEqual, false, Assembler::pt, no_reguard); 2378 __ br(Assembler::notEqual, false, Assembler::pt, no_reguard);
2382 __ delayed()->nop(); 2379 __ delayed()->nop();
2383 2380
2384 save_native_result(masm, ret_type, stack_slots); 2381 save_native_result(masm, ret_type, stack_slots);
2682 // First thing make an ic check to see if we should even be here 2679 // First thing make an ic check to see if we should even be here
2683 2680
2684 { 2681 {
2685 Label L; 2682 Label L;
2686 const Register temp_reg = G3_scratch; 2683 const Register temp_reg = G3_scratch;
2687 Address ic_miss(temp_reg, SharedRuntime::get_ic_miss_stub()); 2684 AddressLiteral ic_miss(SharedRuntime::get_ic_miss_stub());
2688 __ verify_oop(O0); 2685 __ verify_oop(O0);
2689 __ ld_ptr(O0, oopDesc::klass_offset_in_bytes(), temp_reg); 2686 __ ld_ptr(O0, oopDesc::klass_offset_in_bytes(), temp_reg);
2690 __ cmp(temp_reg, G5_inline_cache_reg); 2687 __ cmp(temp_reg, G5_inline_cache_reg);
2691 __ brx(Assembler::equal, true, Assembler::pt, L); 2688 __ brx(Assembler::equal, true, Assembler::pt, L);
2692 __ delayed()->nop(); 2689 __ delayed()->nop();
2693 2690
2694 __ jump_to(ic_miss, 0); 2691 __ jump_to(ic_miss, temp_reg);
2695 __ delayed()->nop(); 2692 __ delayed()->nop();
2696 __ align(CodeEntryAlignment); 2693 __ align(CodeEntryAlignment);
2697 __ bind(L); 2694 __ bind(L);
2698 } 2695 }
2699 2696
3153 3150
3154 // Before we make new frames, check to see if stack is available. 3151 // Before we make new frames, check to see if stack is available.
3155 // Do this after the caller's return address is on top of stack 3152 // Do this after the caller's return address is on top of stack
3156 if (UseStackBanging) { 3153 if (UseStackBanging) {
3157 // Get total frame size for interpreted frames 3154 // Get total frame size for interpreted frames
3158 __ ld(Address(O2UnrollBlock, 0, 3155 __ ld(O2UnrollBlock, Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes(), O4);
3159 Deoptimization::UnrollBlock::total_frame_sizes_offset_in_bytes()), O4);
3160 __ bang_stack_size(O4, O3, G3_scratch); 3156 __ bang_stack_size(O4, O3, G3_scratch);
3161 } 3157 }
3162 3158
3163 __ ld(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::number_of_frames_offset_in_bytes()), O4array_size); 3159 __ ld(O2UnrollBlock, Deoptimization::UnrollBlock::number_of_frames_offset_in_bytes(), O4array_size);
3164 __ ld_ptr(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes()), G3pcs); 3160 __ ld_ptr(O2UnrollBlock, Deoptimization::UnrollBlock::frame_pcs_offset_in_bytes(), G3pcs);
3165 3161 __ ld_ptr(O2UnrollBlock, Deoptimization::UnrollBlock::frame_sizes_offset_in_bytes(), O3array);
3166 __ ld_ptr(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::frame_sizes_offset_in_bytes()), O3array);
3167 3162
3168 // Adjust old interpreter frame to make space for new frame's extra java locals 3163 // Adjust old interpreter frame to make space for new frame's extra java locals
3169 // 3164 //
3170 // We capture the original sp for the transition frame only because it is needed in 3165 // We capture the original sp for the transition frame only because it is needed in
3171 // order to properly calculate interpreter_sp_adjustment. Even though in real life 3166 // order to properly calculate interpreter_sp_adjustment. Even though in real life
3174 // be told the sp_adjustment for each frame we create. If the frame size array 3169 // be told the sp_adjustment for each frame we create. If the frame size array
3175 // were to have twice the frame count entries then we could have pairs [sp_adjustment, frame_size] 3170 // were to have twice the frame count entries then we could have pairs [sp_adjustment, frame_size]
3176 // for each frame we create and keep up the illusion every where. 3171 // for each frame we create and keep up the illusion every where.
3177 // 3172 //
3178 3173
3179 __ ld(Address(O2UnrollBlock, 0, Deoptimization::UnrollBlock::caller_adjustment_offset_in_bytes()), O7); 3174 __ ld(O2UnrollBlock, Deoptimization::UnrollBlock::caller_adjustment_offset_in_bytes(), O7);
3180 __ mov(SP, O5_savedSP); // remember initial sender's original sp before adjustment 3175 __ mov(SP, O5_savedSP); // remember initial sender's original sp before adjustment
3181 __ sub(SP, O7, SP); 3176 __ sub(SP, O7, SP);
3182 3177
3183 #ifdef ASSERT 3178 #ifdef ASSERT
3184 // make sure that there is at least one entry in the array 3179 // make sure that there is at least one entry in the array
3223 Register O2UnrollBlock = O2; 3218 Register O2UnrollBlock = O2;
3224 Register O3tmp = O3; 3219 Register O3tmp = O3;
3225 Register I5exception_tmp = I5; 3220 Register I5exception_tmp = I5;
3226 Register G4exception_tmp = G4_scratch; 3221 Register G4exception_tmp = G4_scratch;
3227 int frame_size_words; 3222 int frame_size_words;
3228 Address saved_Freturn0_addr(FP, 0, -sizeof(double) + STACK_BIAS); 3223 Address saved_Freturn0_addr(FP, -sizeof(double) + STACK_BIAS);
3229 #if !defined(_LP64) && defined(COMPILER2) 3224 #if !defined(_LP64) && defined(COMPILER2)
3230 Address saved_Greturn1_addr(FP, 0, -sizeof(double) -sizeof(jlong) + STACK_BIAS); 3225 Address saved_Greturn1_addr(FP, -sizeof(double) -sizeof(jlong) + STACK_BIAS);
3231 #endif 3226 #endif
3232 Label cont; 3227 Label cont;
3233 3228
3234 OopMapSet *oop_maps = new OopMapSet(); 3229 OopMapSet *oop_maps = new OopMapSet();
3235 3230
3287 // state will be extracted normally. 3282 // state will be extracted normally.
3288 3283
3289 // save exception oop in JavaThread and fall through into the 3284 // save exception oop in JavaThread and fall through into the
3290 // exception_in_tls case since they are handled in same way except 3285 // exception_in_tls case since they are handled in same way except
3291 // for where the pending exception is kept. 3286 // for where the pending exception is kept.
3292 __ st_ptr(Oexception, G2_thread, in_bytes(JavaThread::exception_oop_offset())); 3287 __ st_ptr(Oexception, G2_thread, JavaThread::exception_oop_offset());
3293 3288
3294 // 3289 //
3295 // Vanilla deoptimization with an exception pending in exception_oop 3290 // Vanilla deoptimization with an exception pending in exception_oop
3296 // 3291 //
3297 int exception_in_tls_offset = __ offset() - start; 3292 int exception_in_tls_offset = __ offset() - start;
3304 3299
3305 #ifdef ASSERT 3300 #ifdef ASSERT
3306 { 3301 {
3307 // verify that there is really an exception oop in exception_oop 3302 // verify that there is really an exception oop in exception_oop
3308 Label has_exception; 3303 Label has_exception;
3309 __ ld_ptr(G2_thread, in_bytes(JavaThread::exception_oop_offset()), Oexception); 3304 __ ld_ptr(G2_thread, JavaThread::exception_oop_offset(), Oexception);
3310 __ br_notnull(Oexception, false, Assembler::pt, has_exception); 3305 __ br_notnull(Oexception, false, Assembler::pt, has_exception);
3311 __ delayed()-> nop(); 3306 __ delayed()-> nop();
3312 __ stop("no exception in thread"); 3307 __ stop("no exception in thread");
3313 __ bind(has_exception); 3308 __ bind(has_exception);
3314 3309
3315 // verify that there is no pending exception 3310 // verify that there is no pending exception
3316 Label no_pending_exception; 3311 Label no_pending_exception;
3317 Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset())); 3312 Address exception_addr(G2_thread, Thread::pending_exception_offset());
3318 __ ld_ptr(exception_addr, Oexception); 3313 __ ld_ptr(exception_addr, Oexception);
3319 __ br_null(Oexception, false, Assembler::pt, no_pending_exception); 3314 __ br_null(Oexception, false, Assembler::pt, no_pending_exception);
3320 __ delayed()->nop(); 3315 __ delayed()->nop();
3321 __ stop("must not have pending exception here"); 3316 __ stop("must not have pending exception here");
3322 __ bind(no_pending_exception); 3317 __ bind(no_pending_exception);