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

-:e4aeef458496
+:ffcdff41a92f
 set_num_rt_args(1 + args_size);
 // push java thread (becomes first argument of C function)
-#ifndef OPT_THREAD
 get_thread(thread);
-#endif
 move(A0, thread);
 set_last_Java_frame(thread, NOREG, FP, NULL);
 NOT_LP64(addi(SP, SP, - wordSize * (1+args_size)));
 move(AT, -(StackAlignmentInBytes));
 jmp(StubRoutines::forward_exception_entry(), relocInfo::runtime_call_type);
 delayed()->nop();
 } else if (_stub_id == Runtime1::forward_exception_id) {
 should_not_reach_here();
 } else {
-jmp(Runtime1::entry_for(Runtime1::forward_exception_id),
+jmp(Runtime1::entry_for(Runtime1::forward_exception_id), relocInfo::runtime_call_type);
-relocInfo::runtime_call_type);
 delayed()->nop();
 }
 bind(L);
 }
 // get oop results if there are any and reset the values in the thread
 // to simply save their current value.
 //FIXME, I have no idea which register should be saved . @jerome
 static OopMap* generate_oop_map(StubAssembler* sasm, int num_rt_args,
 bool save_fpu_registers = true, bool describe_fpu_registers = false) {
-/* Jin: num_rt_args is caculated by 8 bytes. */
+LP64_ONLY(num_rt_args = 0);
-int frame_size_in_slots = reg_save_frame_size + num_rt_args * wordSize / SLOT_PER_WORD;   // args + thread
+LP64_ONLY(assert((reg_save_frame_size * VMRegImpl::stack_slot_size) % 16 == 0, "must be 16 byte aligned");)
-sasm->set_frame_size(frame_size_in_slots / SLOT_PER_WORD);
+int frame_size_in_slots = reg_save_frame_size + num_rt_args * wordSize / VMRegImpl::slots_per_word;   // args + thread
+sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word);
 // record saved value locations in an OopMap
 // locations are offsets from sp after runtime call; num_rt_args is number of arguments
 // in call, including thread
 OopMap* map = new OopMap(reg_save_frame_size, 0);
 #endif
 return map;
 }
 //FIXME, Is it enough to save this registers  by yyq
-static OopMap* save_live_registers(StubAssembler* sasm,
+static OopMap* save_live_registers(StubAssembler* sasm, int num_rt_args,
-int num_rt_args,
+bool save_fpu_registers = true,
-bool save_fpu_registers = true,
 bool describe_fpu_registers = false) {
 //const int reg_save_frame_size = return_off + 1 + num_rt_args;
 __ block_comment("save_live_registers");
 // save all register state - int, fpu
 return oop_maps;
 }
 //FIXME I do not know which reigster to use.should use T3 as real_return_addr @jerome
 OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
 __ block_comment("generate_handle_exception");
-// incoming parameters
+// incoming parameters
 const Register exception_oop = V0;
 const Register exception_pc = V1;
 // other registers used in this stub
-//  const Register real_return_addr = T3;
+// const Register real_return_addr = T3;
-const Register thread = T8;
+const Register thread = TREG;
+#ifndef OPT_THREAD
+__ get_thread(thread);
+#endif
 // Save registers, if required.
 OopMapSet* oop_maps = new OopMapSet();
 OopMap* oop_map = NULL;
 switch (id) {
 case forward_exception_id:
 // We're handling an exception in the context of a compiled frame.
 // The registers have been saved in the standard places.  Perform
 // an exception lookup in the caller and dispatch to the handler
 // if found.  Otherwise unwind and dispatch to the callers
 // exception handler.
 oop_map = generate_oop_map(sasm, 1 /*thread*/);
 // load and clear pending exception oop into RAX
-__ ld(exception_oop, Address(thread, Thread::pending_exception_offset()));
+__ ld_ptr(exception_oop, Address(thread, Thread::pending_exception_offset()));
-__ sw(R0,Address(thread, Thread::pending_exception_offset()));
+__ st_ptr(R0, Address(thread, Thread::pending_exception_offset()));
 // load issuing PC (the return address for this stub) into rdx
-__ ld(exception_pc, Address(FP, 1*BytesPerWord));
+__ ld_ptr(exception_pc, Address(FP, 1*BytesPerWord));
 // make sure that the vm_results are cleared (may be unnecessary)
-__ sw(R0,Address(thread, JavaThread::vm_result_offset()));
+__ st_ptr(R0, Address(thread, JavaThread::vm_result_offset()));
-__ sw(R0,Address(thread, JavaThread::vm_result_2_offset()));
+__ st_ptr(R0, Address(thread, JavaThread::vm_result_2_offset()));
 break;
 case handle_exception_nofpu_id:
 case handle_exception_id:
 // At this point all registers MAY be live.
-oop_map = save_live_registers(sasm, 1 /*thread*/, id == handle_exception_nofpu_id);
+oop_map = save_live_registers(sasm, 1 /*thread*/, id != handle_exception_nofpu_id);
 break;
 case handle_exception_from_callee_id: {
 // At this point all registers except exception oop (RAX) and
 // exception pc (RDX) are dead.
-const int frame_size = 2 /*BP, return address*/ NOT_LP64(+ 1 /*thread*/) WIN64_ONLY(+ frame::arg_reg_save_area_by     tes / BytesPerWord);
+const int frame_size = 2 /*BP, return address*/ NOT_LP64(+ 1 /*thread*/);
 oop_map = new OopMap(frame_size * VMRegImpl::slots_per_word, 0);
 sasm->set_frame_size(frame_size);
-WIN64_ONLY(__ subq(rsp, frame::arg_reg_save_area_bytes));
+break;
-break;
+}
-}
+default:  ShouldNotReachHere();
-default:  ShouldNotReachHere();
+}
-}
 #ifdef TIERED
 // C2 can leave the fpu stack dirty
 __ empty_FPU_stack();
-//}
 #endif // TIERED
 // verify that only V0 and V1 is valid at this time
 // verify that V0 contains a valid exception
 __ verify_not_null_oop(exception_oop);
 // save exception oop and issuing pc into JavaThread
 // (exception handler will load it from here)
 __ st_ptr(exception_oop, Address(thread, in_bytes(JavaThread::exception_oop_offset())));
 __ st_ptr(exception_pc, Address(thread, in_bytes(JavaThread::exception_pc_offset())));
-// save real return address (pc that called this stub)
-//  __ ld_ptr(real_return_addr, FP, 1*BytesPerWord);
-//  __ st_ptr(real_return_addr, SP, temp_1_off * BytesPerWord / SLOT_PER_WORD);
 // patch throwing pc into return address (has bci & oop map)
-__ st_ptr(exception_pc, FP, 1*BytesPerWord);
+__ st_ptr(exception_pc, Address(FP, 1*BytesPerWord));
 // compute the exception handler.
 // the exception oop and the throwing pc are read from the fields in JavaThread
-int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address,
+int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
-exception_handler_for_pc));
 oop_maps->add_gc_map(call_offset, oop_map);
 // V0:  handler address or NULL if no handler exists
 //      will be the deopt blob if nmethod was deoptimized while we looked up
 //      handler regardless of whether handler existed in the nmethod.
 // only V0 is valid at this time, all other registers have been destroyed by the
 // runtime call
-// Do we have an exception handler in the nmethod?
-/*Label no_handler;
-Label done;
-__ beq(V0, R0, no_handler);
-__ delayed()->nop(); */
-// exception handler found
 // patch the return address -> the stub will directly return to the exception handler
-__ st_ptr(V0, FP, 1 * BytesPerWord);
+__ st_ptr(V0, Address(FP, 1 * BytesPerWord));
-// restore registers
+switch (id) {
-//  restore_live_registers(sasm, save_fpu_registers);
+case forward_exception_id:
+case handle_exception_nofpu_id:
-// return to exception handler
+case handle_exception_id:
-//  __ leave();
+// Restore the registers that were saved at the beginning.
-//  __ jr(RA);
+restore_live_registers(sasm, id != handle_exception_nofpu_id);
-//  __ delayed()->nop();
+break;
-//  __ bind(no_handler);
+case handle_exception_from_callee_id:
-// no exception handler found in this method, so the exception is
+// WIN64_ONLY: No need to add frame::arg_reg_save_area_bytes to SP
-// forwarded to the caller (using the unwind code of the nmethod)
+// since we do a leave anyway.
-// there is no need to restore the registers
+// Pop the return address since we are possibly changing SP (restoring from BP).
-// restore the real return address that was saved before the RT-call
+__ leave();
-//  __ ld_ptr(real_return_addr, SP, temp_1_off * BytesPerWord / SLOT_PER_WORD);
+// Restore SP from BP if the exception PC is a method handle call site.
-//  __ st_ptr(real_return_addr, FP, 1 * BytesPerWord);
+{
-// load address of JavaThread object for thread-local data
+Label done;
-//  __ get_thread(thread);
+__ ld(AT, Address(thread, JavaThread::is_method_handle_return_offset()));
-// restore exception oop into eax (convention for unwind code)
+__ beq(AT, R0, done);
-//  __ ld_ptr(exception_oop, thread, in_bytes(JavaThread::exception_oop_offset()));
+__ delayed()->nop();
+__ bind(done);
-// clear exception fields in JavaThread because they are no longer needed
+}
-// (fields must be cleared because they are processed by GC otherwise)
+__ jr(RA);  // jump to exception handler
-//  __ st_ptr(R0, thread, in_bytes(JavaThread::exception_oop_offset()));
+__ delayed()->nop();
-//  __ st_ptr(R0,thread, in_bytes(JavaThread::exception_pc_offset()));
+break;
-// pop the stub frame off
-//  __ leave();
-//  generate_unwind_exception(sasm);
-//  __ stop("should not reach here");
-//}
-switch (id) {
-case forward_exception_id:
-case handle_exception_nofpu_id:
-case handle_exception_id:
-// Restore the registers that were saved at the beginning.
-restore_live_registers(sasm, id == handle_exception_nofpu_id);
-break;
-case handle_exception_from_callee_id:
-// WIN64_ONLY: No need to add frame::arg_reg_save_area_bytes to SP
-// since we do a leave anyway.
-// Pop the return address since we are possibly changing SP (restoring from BP).
-__ leave();
-// Restore SP from BP if the exception PC is a method handle call site.
-NOT_LP64(__ get_thread(thread);)
-/*__ ld(AT, Address(thread, JavaThread::is_method_handle_return_offset()));
-__ beq(AT, R0, done);
-__ move(SP, rbp_mh_SP_save);
-__ bind(done);
-__ jr(RA);  // jump to exception handler
-__ delayed()->nop();*/
-// 759     __ cmpl(Address(thread, JavaThread::is_method_handle_return_offset()), 0);
-// 760     __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
-// 761     __ jmp(rcx);  // jump to exception handler
-break;
 default:  ShouldNotReachHere();
 }
 return oop_maps;
 }
 void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
 // incoming parameters
 const Register exception_oop = V0;
+// callee-saved copy of exception_oop during runtime call
+const Register exception_oop_callee_saved = S0;
 // other registers used in this stub
 const Register exception_pc = V1;
 const Register handler_addr = T3;
-const Register thread = T8;
+const Register thread = TREG;
 // verify that only eax is valid at this time
 //  __ invalidate_registers(false, true, true, true, true, true);
 #ifdef ASSERT
 __ stop("exception oop must be empty");
 __ bind(oop_empty);
 Label pc_empty;
 __ ld_ptr(AT, thread, in_bytes(JavaThread::exception_pc_offset()));
-__ beq(AT,R0, pc_empty);
+__ beq(AT, R0, pc_empty);
 __ delayed()->nop();
 __ stop("exception pc must be empty");
 __ bind(pc_empty);
 #endif
 // clear the FPU stack in case any FPU results are left behind
 __ empty_FPU_stack();
-// leave activation of nmethod
+// save exception_oop in callee-saved register to preserve it during runtime calls
-__ addi(SP, FP, wordSize);
+__ verify_not_null_oop(exception_oop);
-__ ld_ptr(FP, SP, - wordSize);
+__ move(exception_oop_callee_saved, exception_oop);
+#ifndef OPT_THREAD
+__ get_thread(thread);
+#endif
+// Get return address (is on top of stack after leave).
 // store return address (is on top of stack after leave)
 __ ld_ptr(exception_pc, SP, 0);
-__ verify_oop(exception_oop);
-// save exception oop from eax to stack before call
-__ push(exception_oop);
 // search the exception handler address of the caller (using the return address)
-__ call_VM_leaf(CAST_FROM_FN_PTR(address,
+__ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, exception_pc);
-SharedRuntime::exception_handler_for_return_address), exception_pc);
+// V0: exception handler address of the caller
-// eax: exception handler address of the caller
 // only eax is valid at this time, all other registers have been destroyed by the call
 // move result of call into correct register
 __ move(handler_addr, V0);
-// restore exception oop in eax (required convention of exception handler)
-__ super_pop(exception_oop);
+// Restore exception oop to V0 (required convention of exception handler).
+__ move(exception_oop, exception_oop_callee_saved);
+// verify that there is really a valid exception in V0
 __ verify_oop(exception_oop);
 // get throwing pc (= return address).
-// edx has been destroyed by the call, so it must be set again
+// V1 has been destroyed by the call, so it must be set again
 // the pop is also necessary to simulate the effect of a ret(0)
 __ super_pop(exception_pc);
-// verify that that there is really a valid exception in eax
-__ verify_not_null_oop(exception_oop);
 // continue at exception handler (return address removed)
 // note: do *not* remove arguments when unwinding the
 //       activation since the caller assumes having
 //       all arguments on the stack when entering the
 //       runtime to determine the exception handler
 //       (GC happens at call site with arguments!)
-// eax: exception oop
+// V0: exception oop
-// edx: throwing pc
+// V1: throwing pc
-// ebx: exception handler
+// T3: exception handler
 __ jr(handler_addr);
 __ delayed()->nop();
 }
 // use the maximum number of runtime-arguments here because it is difficult to
 // distinguish each RT-Call.
 // Note: This number affects also the RT-Call in generate_handle_exception because
 //       the oop-map is shared for all calls.
 DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
 assert(deopt_blob != NULL, "deoptimization blob must have been created");
 // assert(deopt_with_exception_entry_for_patch != NULL,
 // "deoptimization blob must have been created");
 //OopMap* oop_map = save_live_registers(sasm, num_rt_args);
 OopMap* oop_map = save_live_registers(sasm, 0);
-#ifndef OPT_THREAD
 const Register thread = T8;
 // push java thread (becomes first argument of C function)
 __ get_thread(thread);
-#else
-const Register thread = TREG;
-#endif
 __ move(A0, thread);
 /*
 *  NOTE: this frame should be compiled frame, but at this point, the pc in frame-anchor
 __ jalr(T9);
 __ delayed()->nop();
 OopMapSet*  oop_maps = new OopMapSet();
 oop_maps->add_gc_map(__ offset(),  oop_map);
-#ifndef OPT_THREAD
 __ get_thread(thread);
-#endif
 __ ld_ptr (SP, thread, in_bytes(JavaThread::last_Java_sp_offset()));
 __ reset_last_Java_frame(thread, true,true);
 // discard thread arg
 // check for pending exceptions
 __ ld_ptr(AT, thread, in_bytes(Thread::pending_exception_offset()));
 __ beq(AT, R0, L);
 __ delayed()->nop();
 // exception pending => remove activation and forward to exception handler
-__ bne(V0,R0, skip);
+__ bne(V0, R0, skip);
 __ delayed()->nop();
-//      relocInfo::runtime_call_type);
 __ jmp(Runtime1::entry_for(Runtime1::forward_exception_id),
 relocInfo::runtime_call_type);
 __ delayed()->nop();
 __ bind(skip);
 OopMapSet* oop_maps = NULL;
 switch (id) {
 case forward_exception_id:
 {
-// we're handling an exception in the context of a compiled
+oop_maps = generate_handle_exception(id, sasm);
-// frame.  The registers have been saved in the standard
+__ leave();
-// places.  Perform an exception lookup in the caller and
+__ jr(RA);
-// dispatch to the handler if found.  Otherwise unwind and
+__ delayed()->nop();
-// dispatch to the callers exception handler.
-const Register exception_oop = V0;
-const Register exception_pc = V1;
-#ifndef OPT_THREAD
-const Register thread = T8;
-__ get_thread(thread);
-#else
-const Register thread = TREG;
-#endif
-// load pending exception oop into eax
-__ ld_ptr(exception_oop, thread, in_bytes(Thread::pending_exception_offset()));
-// clear pending exception
-__ st_ptr(R0, thread, in_bytes(Thread::pending_exception_offset()));
-// load issuing PC (the return address for this stub) into V1
-__ ld_ptr(exception_pc, FP, 1*BytesPerWord);
-// make sure that the vm_results are cleared (may be unnecessary)
-__ st_ptr(R0, Address(thread, in_bytes(JavaThread::vm_result_offset())));
-__ st_ptr(R0, Address(thread, in_bytes(JavaThread::vm_result_2_offset())));
-// verify that that there is really a valid exception in eax
-__ verify_not_null_oop(exception_oop);
-oop_maps = new OopMapSet();
-OopMap* oop_map = generate_oop_map(sasm, 0);
-generate_handle_exception(id, sasm);
-__ stop("should not reach here");
 }
 break;
 case new_instance_id:
 case fast_new_instance_id:
 case fast_new_instance_init_check_id:
 {
-// i use T4 as klass register, V0 as result register. MUST accord with NewInstanceStub::emit_code
-#ifndef _LP64
-Register klass = T4; // Incoming
-#else
 Register klass = A4; // Incoming
-#endif
 Register obj   = V0; // Result
 if (id == new_instance_id) {
 __ set_info("new_instance", dont_gc_arguments);
 } else if (id == fast_new_instance_id) {
 Register t1       = T2;
 Register t2       = T3;
 assert_different_registers(klass, obj, obj_size, t1, t2);
 if (id == fast_new_instance_init_check_id) {
 // make sure the klass is initialized
-__ lw(AT, klass, in_bytes(InstanceKlass::init_state_offset()));
+__ ld_ptr(AT, Address(klass, in_bytes(InstanceKlass::init_state_offset())));
 __ move(t1, InstanceKlass::fully_initialized);
 __ bne(AT, t1, slow_path);
 __ delayed()->nop();
 }
 #ifdef ASSERT
 #ifndef _LP64
 Register bci = T5;
 #else
 Register bci = A5;
 #endif
+Register method = AT;
 __ enter();
 OopMap* map = save_live_registers(sasm, 0);
 // Retrieve bci
 __ lw(bci, Address(FP, 2*BytesPerWord));// FIXME:wuhui.ebp==??
-int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci);
+__ ld(method, Address(FP, 3*BytesPerWord));
+int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci, method);
 oop_maps = new OopMapSet();
 oop_maps->add_gc_map(call_offset, map);
 restore_live_registers(sasm);
 __ leave();
 __ jr(RA);
 }
 break;
 //  case range_check_failed_id:
 case throw_range_check_failed_id:
-{ StubFrame f(sasm, "range_check_failed", dont_gc_arguments);
+{
+StubFrame f(sasm, "range_check_failed", dont_gc_arguments);
 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address,
 throw_range_check_exception),true);
 }
 break;
 throw_div0_exception), false);
 }
 break;
 case throw_null_pointer_exception_id:
-{ StubFrame f(sasm, "throw_null_pointer_exception", dont_gc_arguments);
+{
+StubFrame f(sasm, "throw_null_pointer_exception", dont_gc_arguments);
 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address,
 throw_null_pointer_exception),false);
 }
 break;
 case handle_exception_nofpu_id:
 save_fpu_registers = false;
 // fall through
 case handle_exception_id:
 {
 StubFrame f(sasm, "handle_exception", dont_gc_arguments);
 //OopMap* oop_map = save_live_registers(sasm, 1, save_fpu_registers);
 oop_maps = generate_handle_exception(id, sasm);
 }
 break;
 case handle_exception_from_callee_id:
 {
 StubFrame f(sasm, "handle_exception_from_callee", dont_gc_arguments);
 oop_maps = generate_handle_exception(id, sasm);
 }
 break;
 case unwind_exception_id:
 {
 __ set_info("unwind_exception", dont_gc_arguments);
 generate_unwind_exception(sasm);
 }
 break;
 case throw_array_store_exception_id:
-{ StubFrame f(sasm, "throw_array_store_exception", dont_gc_arguments);
+{
+StubFrame f(sasm, "throw_array_store_exception", dont_gc_arguments);
 // tos + 0: link
 //     + 1: return address
 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address,
 throw_array_store_exception), false);
 }
 break;
 case throw_class_cast_exception_id:
-{ StubFrame f(sasm, "throw_class_cast_exception", dont_gc_arguments);
+{
+StubFrame f(sasm, "throw_class_cast_exception", dont_gc_arguments);
 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address,
-throw_class_cast_exception), V0);
+throw_class_cast_exception), true);
 }
 break;
 case throw_incompatible_class_change_error_id:
 {
 StubFrame f(sasm, "throw_incompatible_class_cast_exception", dont_gc_arguments);
 oop_maps = generate_exception_throw(sasm,
 CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
 }
 break;
 case slow_subtype_check_id:
 {
 Runtime1::post_jvmti_exception_throw), V0);
 oop_maps = new OopMapSet();
 oop_maps->add_gc_map(call_offset,  map);
 restore_live_registers(sasm);
 }*/
 case load_mirror_patching_id:
 {
 StubFrame f(sasm, "load_mirror_patching" , dont_gc_arguments);
 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_mirror_patching));
 }
 break;
+case load_appendix_patching_id:
+{
+StubFrame f(sasm, "load_appendix_patching", dont_gc_arguments);
+// we should set up register map
+oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_appendix_patching));
+}
+break;
 case dtrace_object_alloc_id:
 {
 // V0:object
 StubFrame f(sasm, "dtrace_object_alloc", dont_gc_arguments);
 // we can't gc here so skip the oopmap but make sure that all
 // the live registers get saved.
 save_live_registers(sasm, 0);
 __ push_reg(V0);
+__ move(A0, V0);
 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc),
 relocInfo::runtime_call_type);
 __ super_pop(V0);
 restore_live_registers(sasm);
 }
 break;
 case fpu2long_stub_id:
 {
 //FIXME, I hava no idea how to port this
-}
+//tty->print_cr("fpu2long_stub_id unimplemented yet!");
+}
+break;
+case deoptimize_id:
+{
+StubFrame f(sasm, "deoptimize", dont_gc_arguments);
+const int num_rt_args = 1;  // thread
+OopMap* oop_map = save_live_registers(sasm, num_rt_args);
+int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, deoptimize));
+oop_maps = new OopMapSet();
+oop_maps->add_gc_map(call_offset, oop_map);
+restore_live_registers(sasm);
+DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
+assert(deopt_blob != NULL, "deoptimization blob must have been created");
+__ leave();
+__ jmp(deopt_blob->unpack_with_reexecution(), relocInfo::runtime_call_type);
+}
+break;
+case predicate_failed_trap_id:
+{
+StubFrame f(sasm, "predicate_failed_trap", dont_gc_arguments);
+OopMap* map = save_live_registers(sasm, 1);
+int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, predicate_failed_trap));
+oop_maps = new OopMapSet();
+oop_maps->add_gc_map(call_offset, map);
+restore_live_registers(sasm);
+__ leave();
+DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
+assert(deopt_blob != NULL, "deoptimization blob must have been created");
+__ jmp(deopt_blob->unpack_with_reexecution(), relocInfo::runtime_call_type);
+}
+break;
 default:
-{ StubFrame f(sasm, "unimplemented entry", dont_gc_arguments);
+{
+StubFrame f(sasm, "unimplemented entry", dont_gc_arguments);
 __ move(A1, (int)id);
 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), A1);
 __ should_not_reach_here();
 }
 break;

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

src/cpu/mips/vm/c1_Runtime1_mips.cpp

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

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

src/cpu/mips/vm/c1_Runtime1_mips.cpp