jdk8-mips64-public/hotspot: comparison src/cpu/mips/vm/sharedRuntime_mips

-:2c1fab4a6f4e
+:0477693968a6
 __ move(AT, -(StackAlignmentInBytes));
 __ andr(SP, SP, AT);
 // push the return address on the stack (note that pushing, rather
 // than storing it, yields the correct frame alignment for the callee)
 // Put saved SP in another register
-// const Register saved_sp = eax;
 const Register saved_sp = V0;
 __ move(saved_sp, T9);
 // Will jump to the compiled code just as if compiled code was doing it.
 case T_DOUBLE:
 __ sdc1(FSF, FP, -wordSize );
 break;
 case T_VOID:  break;
 case T_LONG:
 __ sd(V0, FP, -wordSize);
 break;
 case T_OBJECT:
 case T_ARRAY:
 __ sd(V0, FP, -wordSize);
 break;
 default: {
 __ sw(V0, FP, -wordSize);
 }
 }
 }
 void SharedRuntime::restore_native_result(MacroAssembler *masm, BasicType ret_type, int frame_slots) {
 // We always ignore the frame_slots arg and just use the space just below frame pointer
 case T_OBJECT:
 case T_ARRAY:
 __ ld(V0, FP, -wordSize);
 break;
 default: {
 __ lw(V0, FP, -wordSize);
 }
 }
 }
 static void save_args(MacroAssembler *masm, int arg_count, int first_arg, VMRegPair *args) {
 for ( int i = first_arg ; i < arg_count ; i++ ) {
 // 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);
 out_arg_slots = c_calling_convention(out_sig_bt, out_regs, NULL, total_c_args);
 // 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
 // instruction fits that requirement.
 // Generate stack overflow check
 if (UseStackBanging) {
-//this function will modify the value in A0
-__ push(A0);
 __ bang_stack_with_offset(StackShadowPages*os::vm_page_size());
-__ pop(A0);
 } else {
 // need a 5 byte instruction to allow MT safe patching to non-entrant
 __ nop();
 __ nop();
 __ nop();
 #ifndef OPT_THREAD
 __ get_thread(TREG);
 #endif
 //FIXME here
 __ st_ptr(SP, TREG, in_bytes(JavaThread::last_Java_sp_offset()));
-// -2 because return address is already present and so is saved ebp
 __ move(AT, -(StackAlignmentInBytes));
 __ andr(SP, SP, AT);
 __ enter();
+// -2 because return address is already present and so is saved ebp
 __ addiu(SP, SP, -1 * (stack_size - 2*wordSize));
 // Frame is now completed as far a size and linkage.
 int frame_complete = ((intptr_t)__ pc()) - start;
 // expression: ((mark - esp) & (3 - os::vm_page_size())),
 // assuming both stack pointer and pagesize have their
 // least significant 2 bits clear.
 // NOTE: the oopMark is in swap_reg %eax as the result of cmpxchg
-__ dsub(swap_reg, swap_reg,SP);
+__ dsub(swap_reg, swap_reg, SP);
 __ move(AT, 3 - os::vm_page_size());
 __ andr(swap_reg , swap_reg, AT);
 // Save the test result, for recursive case, the result is zero
 __ sd(swap_reg, lock_reg, mark_word_offset);
 //FIXME here, Why notEqual?
-__ bne(swap_reg,R0, slow_path_lock);
+__ bne(swap_reg, R0, slow_path_lock);
 __ delayed()->nop();
 // Slow path will re-enter here
 __ bind(lock_done);
 if (UseBiasedLocking) {
 // Finally just about ready to make the JNI call
 // get JNIEnv* which is first argument to native
 if (!is_critical_native) {
 __ addi(A0, thread, in_bytes(JavaThread::jni_environment_offset()));
 }
 // Example: Java_java_lang_ref_Finalizer_invokeFinalizeMethod(JNIEnv *env, jclass clazz, jobject ob)
 /* Load the second arguments into A1 */
 //__ ld(A1, SP , wordSize );   // klass
 // 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.
-// __ movl(Address(thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
-//__ sw(_thread_in_native_trans, thread, JavaThread::thread_state_offset());
-//   __ move(AT, (int)_thread_in_native_trans);
 __ addi(AT, R0, _thread_in_native_trans);
 __ sw(AT, thread, in_bytes(JavaThread::thread_state_offset()));
+//if(os::is_MP()) {}
 Label after_transition;
 // check for safepoint operation in progress and/or pending suspend requests
-{ Label Continue;
+{
-//FIXME here, which regiser should we use?
+Label Continue;
-//        SafepointSynchronize::_not_synchronized);
 __ li(AT, SafepointSynchronize::address_of_state());
 __ lw(A0, AT, 0);
 __ addi(AT, A0, -SafepointSynchronize::_not_synchronized);
 Label L;
 __ bne(AT,R0, L);
 // Also can't use call_VM_leaf either as it will check to see if esi & edi are
 // preserved and correspond to the bcp/locals pointers. So we do a runtime call
 // by hand.
 //
 save_native_result(masm, ret_type, stack_slots);
-__ move (A0, thread);
+__ move(A0, thread);
-__ addi(SP,SP, -wordSize);
+__ addi(SP, SP, -wordSize);
 __ push(S2);
 __ move(AT, -(StackAlignmentInBytes));
 __ move(S2, SP);     // use S2 as a sender SP holder
 __ andr(SP, SP, AT); // align stack as required by ABI
 if (!is_critical_native) {
 __ reset_last_Java_frame(false, true);
 // Unpack oop result
 if (ret_type == T_OBJECT || ret_type == T_ARRAY) {
 Label L;
-__ beq(V0, R0,L );
+__ beq(V0, R0, L);
 __ delayed()->nop();
 __ ld(V0, V0, 0);
 __ bind(L);
 __ verify_oop(V0);
 }
 if (!is_critical_native) {
 // reset handle block
 __ ld(AT, thread, in_bytes(JavaThread::active_handles_offset()));
 __ sw(R0, AT, JNIHandleBlock::top_offset_in_bytes());
 }
 if (!is_critical_native) {
 // Any exception pending?
 __ ld(AT, thread, in_bytes(Thread::pending_exception_offset()));
 __ bne(AT, R0, exception_pending);
 __ delayed()->nop();
 }
 // no exception, we're almost done
 // Return
 #ifndef OPT_THREAD
 __ get_thread(TREG);
 #endif
-__ ld_ptr(SP, TREG, in_bytes(JavaThread::last_Java_sp_offset()));
+//__ ld_ptr(SP, TREG, in_bytes(JavaThread::last_Java_sp_offset()));
 __ leave();
 __ jr(RA);
 __ delayed()->nop();
 // Unexpected paths are out of line and go here
 // remove possible return value from FPU register stack
 __ empty_FPU_stack();
 // pop our frame
 //forward_exception_entry need return address on stack
 __ addiu(SP, FP, wordSize);
 __ ld(FP, SP, (-1) * wordSize);
 // and forward the exception
 __ jmp(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
 __ delayed()->nop();
 // allocate space for the code
 ResourceMark rm;
 //CodeBuffer buffer(name, 1000, 512);
 //FIXME. aoqi. code_size
-CodeBuffer buffer(name, 20000, 2048);
+CodeBuffer buffer(name, 2000, 2048);
 MacroAssembler* masm  = new MacroAssembler(&buffer);
 int frame_size_words;
 //we put the thread in A0

comparison: src/cpu/mips/vm/sharedRuntime_mips_64.cpp

src/cpu/mips/vm/sharedRuntime_mips_64.cpp

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/cpu/mips/vm/sharedRuntime_mips_64.cpp

src/cpu/mips/vm/sharedRuntime_mips_64.cpp