Cross Reference: /openjdk7/hotspot/src/cpu/sparc/vm/sharedRuntime

Lines Matching refs:SP
138   __ save(SP, -frame_size, SP);
151   __ stx(O0, SP, o0_offset+STACK_BIAS);
154   __ stx(O1, SP, o1_offset+STACK_BIAS);
158   __ stx(O2, SP, o2_offset+STACK_BIAS);
161   __ stx(O3, SP, o3_offset+STACK_BIAS);
164   __ stx(O4, SP, o4_offset+STACK_BIAS);
167   __ stx(O5, SP, o5_offset+STACK_BIAS);
178   __ stx(G1, SP, g1_offset+STACK_BIAS);
181   __ stx(G3, SP, g3_offset+STACK_BIAS);
184   __ stx(G4, SP, g4_offset+STACK_BIAS);
187   __ stx(G5, SP, g5_offset+STACK_BIAS);
209   __ stx(G5, SP, ccr_offset+STACK_BIAS);
210   __ stxfsr(SP, fsr_offset+STACK_BIAS);
216     __ stf(FloatRegisterImpl::D,  f, SP, offset+STACK_BIAS);
235     __ ldf(FloatRegisterImpl::D, SP, d00_offset+i*sizeof(float)+STACK_BIAS, as_FloatRegister(i));
238   __ ldx(SP, ccr_offset+STACK_BIAS, G1);
245   __ ldx(SP, g1_offset+STACK_BIAS, G1);
246   __ ldx(SP, g3_offset+STACK_BIAS, G3);
247   __ ldx(SP, g4_offset+STACK_BIAS, G4);
248   __ ldx(SP, g5_offset+STACK_BIAS, G5);
253   __ ldx(SP, o0_offset+STACK_BIAS, O0);
254   __ ldx(SP, o1_offset+STACK_BIAS, O1);
255   __ ldx(SP, o2_offset+STACK_BIAS, O2);
256   __ ldx(SP, o3_offset+STACK_BIAS, O3);
257   __ ldx(SP, o4_offset+STACK_BIAS, O4);
258   __ ldx(SP, o5_offset+STACK_BIAS, O5);
272   __ ldxfsr(SP, fsr_offset+STACK_BIAS);
294   __ ldx(SP, g1_offset+STACK_BIAS, G1);
297   __ ldx(SP, o0_offset+STACK_BIAS, O0);
298   __ ldx(SP, o1_offset+STACK_BIAS, O1);
304   __ ldf(FloatRegisterImpl::D, SP, d00_offset+STACK_BIAS, as_FloatRegister(0));
689   const Register base = SP;
692   __ sub(SP, __ ensure_simm13_or_reg(extraspace, G3_scratch), SP);
736   // The interpreter will restore SP to this value before returning.
737   __ add(SP, __ ensure_simm13_or_reg(extraspace, G1), O5_savedSP);
747   __ delayed()->add(SP, G1, Gargs);
838   // O5_savedSP     - Caller's saved SP, to be restored if needed
839   // O6             - Current SP!
846   // O6             - Adjusted or restored SP
869   // +--------------+ <--- SP + 16*wordsize
873   // +--------------+ <--- SP
893   // +--------------+ <--- SP' + 16*wordsize
897   // +--------------+ <--- SP'
910     // Now compute the distance from Lesp to SP.  This calculation does not
913     __ sub(SP, (comp_words_on_stack)*wordSize, SP);
983       // Convert stack slot to an SP offset
987       if (!r_2->is_valid()) __ stf(FloatRegisterImpl::S, r_1->as_FloatRegister(), SP, slot);
988       else                  __ stf(FloatRegisterImpl::D, r_1->as_FloatRegister(), SP, slot);
1043   // from the interpreter, the interpreter will restore our SP (lest the
1044   // compiled code, which relys solely on SP and not FP, get sick).
1238     __ stf(FloatRegisterImpl::S, F0, SP, frame_slots*VMRegImpl::stack_slot_size - 4+STACK_BIAS);
1241     __ stf(FloatRegisterImpl::D, F0, SP, frame_slots*VMRegImpl::stack_slot_size - 8+STACK_BIAS);
1249     __ ldf(FloatRegisterImpl::S, SP, frame_slots*VMRegImpl::stack_slot_size - 4+STACK_BIAS, F0);
1252     __ ldf(FloatRegisterImpl::D, SP, frame_slots*VMRegImpl::stack_slot_size - 8+STACK_BIAS, F0);
1281       __ st(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
1288     __ st(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
1303       __ st_ptr(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
1310     __ st_ptr(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
1322       __ st_ptr(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
1329     __ st_ptr(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
1360       __ st_ptr(rHandle, SP, reg2offset(dst.first()) + STACK_BIAS);
1374     __ st_ptr(rOop, SP, offset + STACK_BIAS);
1379     __ add(SP, offset + STACK_BIAS, rHandle);
1388       __ st_ptr(rHandle, SP, reg2offset(dst.first()) + STACK_BIAS);
1403       __ st(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
1415       __ st(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
1417       __ stf(FloatRegisterImpl::S, src.first()->as_FloatRegister(), SP, reg2offset(dst.first()) + STACK_BIAS);
1536       __ st(L5, SP, reg2offset(dst.first()) + STACK_BIAS);
1537       __ st(L4, SP, reg2offset(dst.second()) + STACK_BIAS);
1549         __ st(L4, SP, reg2offset(dst.second()) + STACK_BIAS);
1566       __ st(src.first()->as_Register(), SP, reg2offset(dst.first()) + STACK_BIAS);
1569         __ st(L4, SP, reg2offset(dst.second()) + STACK_BIAS);
1571         __ st(src.second()->as_Register(), SP, reg2offset(dst.second()) + STACK_BIAS);
1581           __ stf(FloatRegisterImpl::S, src.first()->as_FloatRegister(), SP, reg2offset(dst.first()) + STACK_BIAS);
1582           __ stf(FloatRegisterImpl::S, src.second()->as_FloatRegister(), SP, reg2offset(dst.second()) + STACK_BIAS);
1584           __ stf(FloatRegisterImpl::D, src.first()->as_FloatRegister(), SP, reg2offset(dst.first()) + STACK_BIAS);
1615         __ st(L4, SP, reg2offset(dst.second()) + STACK_BIAS);
1677           __ stx(reg, SP, offset + STACK_BIAS);
1679           __ ldx(SP, offset + STACK_BIAS, reg);
1686         __ stf(FloatRegisterImpl::D, in_regs[i].first()->as_FloatRegister(), SP, offset + STACK_BIAS);
1688         __ ldf(FloatRegisterImpl::D, SP, offset + STACK_BIAS, in_regs[i].first()->as_FloatRegister());
1700         __ stf(FloatRegisterImpl::S, in_regs[i].first()->as_FloatRegister(), SP, offset + STACK_BIAS);
1702         __ ldf(FloatRegisterImpl::S, SP, offset + STACK_BIAS, in_regs[i].first()->as_FloatRegister());
1736   __ set_last_Java_frame(SP, noreg);
1814           __ ld_ptr(SP, ld_off, temp_reg);
1854       __ ld_ptr(SP, ld_off, member_reg);
1875       __ ld_ptr(SP, ld_off, receiver_reg);
2198   // SP-> | out_preserved_slots |
2213   __ save(SP, -stack_size, SP);
2329     __ st_ptr(O1, SP, klass_offset + STACK_BIAS);
2331     __ add(SP, klass_offset + STACK_BIAS, O1);
2471     __ st_ptr(FP, SP, FP->sp_offset_in_saved_window()*wordSize + STACK_BIAS);
2472     __ st_ptr(I7, SP, I7->sp_offset_in_saved_window()*wordSize + STACK_BIAS);
2481   __ set_last_Java_frame(SP, O7);
2627     __ add(SP, lock_offset+STACK_BIAS, L3_box);
2635     __ delayed()-> add(SP, lock_offset+STACK_BIAS, L3_box);
2684   // Clear "last Java frame" SP and PC.
2888   // SP-> | out_preserved_slots |
2930   __ save(SP, -stack_size, SP);
3052                 __ st_ptr(s, SP, reg2offset(dst.first()) + STACK_BIAS);
3062                   __ st_ptr(d, SP, reg2offset(dst.first()) + STACK_BIAS);
3072               __ st_ptr(G0, SP, reg2offset(dst.first()) + STACK_BIAS);
3092                      SP, off);
3093               __ ld(SP, off, d);
3100                      SP, conversion_off);
3101               __ ld(SP, conversion_off , d);
3108                      SP, off);
3115                      SP, conversion_off);
3140                    SP, off);
3141             __ ld_long(SP, off, d);
3148                    SP, conversion_off);
3149             __ ld_long(SP, conversion_off, d);
3169             __ stx(src.first()->as_Register(), SP, off);
3170             __ ld_long(SP, off, tmp);
3176             __ stx(src.first()->as_Register(), SP, conversion_off);
3177             __ ld_long(SP, conversion_off, tmp);
3311   __ save(SP, O7frame_size, SP);
3317   __ btst(wordSize*2-1, SP);
3354   __ mov(SP, O5_savedSP);
3394   __ mov(SP, O5_savedSP);       // remember initial sender's original sp before adjustment
3395   __ sub(SP, O7, SP);
3554   __ set_last_Java_frame(SP, noreg);
3602   __ save(SP, -frame_size_words*wordSize, SP);
3609   __ set_last_Java_frame(SP, noreg);
3614   __ set_last_Java_frame(SP, G0);
3691   __ set_last_Java_frame(SP, noreg);
3711   __ set_last_Java_frame(SP, noreg);
3742 // SP and mess up HIS OopMaps.  So we first adjust the caller's SP, then save
3743 // the 64-bit %o's, then do a save, then fixup the caller's SP (our FP).
3778   __ set_last_Java_frame(SP, noreg);
3863   __ set_last_Java_frame(SP, noreg);
3893   __ stx(G5_method, SP, RegisterSaver::G5_offset()+STACK_BIAS);
3897   __ stx(O0, SP, RegisterSaver::G3_offset()+STACK_BIAS);