Lines Matching defs:__
211 #define __ _sasm->
215 __ set_info(name, must_gc_arguments);
216 __ enter();
228 __ movptr(reg, Address(rbp, (offset_in_words + 2) * BytesPerWord));
233 __ leave();
234 __ ret(0);
237 #undef __
242 #define __ sasm->
409 __ block_comment("save_live_registers");
411 __ pusha(); // integer registers
416 __ subptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size);
419 __ movptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef);
425 __ fnsave(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
426 __ fwait();
430 __ cmpw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std());
431 __ jccb(Assembler::equal, ok);
432 __ stop("corrupted control word detected");
433 __ bind(ok);
440 __ movw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std());
441 __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
444 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
445 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
446 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
447 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
448 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
449 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
450 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
451 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
460 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0);
461 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1);
462 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2);
463 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3);
464 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4);
465 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5);
466 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6);
467 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7);
469 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64), xmm8);
470 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72), xmm9);
471 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80), xmm10);
472 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88), xmm11);
473 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96), xmm12);
474 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104), xmm13);
475 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112), xmm14);
476 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120), xmm15);
480 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0);
481 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1);
482 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2);
483 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3);
484 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4);
485 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5);
486 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6);
487 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7);
492 __ verify_FPU(0, "save_live_registers");
502 __ movdbl(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
503 __ movdbl(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
504 __ movdbl(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
505 __ movdbl(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
506 __ movdbl(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
507 __ movdbl(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
508 __ movdbl(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
509 __ movdbl(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
511 __ movdbl(xmm8, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64));
512 __ movdbl(xmm9, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72));
513 __ movdbl(xmm10, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80));
514 __ movdbl(xmm11, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88));
515 __ movdbl(xmm12, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96));
516 __ movdbl(xmm13, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104));
517 __ movdbl(xmm14, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112));
518 __ movdbl(xmm15, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120));
522 __ movflt(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
523 __ movflt(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
524 __ movflt(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
525 __ movflt(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
526 __ movflt(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
527 __ movflt(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
528 __ movflt(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
529 __ movflt(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
533 __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
536 __ verify_FPU(0, "restore_live_registers");
541 __ verify_FPU(0, "restore_live_registers");
547 __ cmpptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef);
548 __ jcc(Assembler::equal, ok);
549 __ stop("bad offsets in frame");
550 __ bind(ok);
554 __ addptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size);
559 __ block_comment("restore_live_registers");
562 __ popa();
567 __ block_comment("restore_live_registers_except_rax");
572 __ movptr(r15, Address(rsp, 0));
573 __ movptr(r14, Address(rsp, wordSize));
574 __ movptr(r13, Address(rsp, 2 * wordSize));
575 __ movptr(r12, Address(rsp, 3 * wordSize));
576 __ movptr(r11, Address(rsp, 4 * wordSize));
577 __ movptr(r10, Address(rsp, 5 * wordSize));
578 __ movptr(r9, Address(rsp, 6 * wordSize));
579 __ movptr(r8, Address(rsp, 7 * wordSize));
580 __ movptr(rdi, Address(rsp, 8 * wordSize));
581 __ movptr(rsi, Address(rsp, 9 * wordSize));
582 __ movptr(rbp, Address(rsp, 10 * wordSize));
584 __ movptr(rbx, Address(rsp, 12 * wordSize));
585 __ movptr(rdx, Address(rsp, 13 * wordSize));
586 __ movptr(rcx, Address(rsp, 14 * wordSize));
588 __ addptr(rsp, 16 * wordSize);
591 __ pop(rdi);
592 __ pop(rsi);
593 __ pop(rbp);
594 __ pop(rbx); // skip this value
595 __ pop(rbx);
596 __ pop(rdx);
597 __ pop(rcx);
598 __ addptr(rsp, BytesPerWord);
618 __ invalidate_registers(true, true, true, true, true, true);
626 __ movptr(c_rarg1, Address(rbp, 2*BytesPerWord));
628 __ movptr(temp_reg, Address(rbp, 2*BytesPerWord));
629 __ push(temp_reg);
632 int call_offset = __ call_RT(noreg, noreg, target, num_rt_args - 1);
637 __ stop("should not reach here");
644 __ block_comment("generate_handle_exception");
665 __ movptr(exception_oop, Address(thread, Thread::pending_exception_offset()));
666 __ movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
669 __ movptr(exception_pc, Address(rbp, 1*BytesPerWord));
672 __ movptr(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
673 __ movptr(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
686 WIN64_ONLY(__ subq(rsp, frame::arg_reg_save_area_bytes));
695 __ empty_FPU_stack();
700 __ invalidate_registers(false, true, true, false, true, true);
702 __ verify_not_null_oop(exception_oop);
705 NOT_LP64(__ get_thread(thread);)
711 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), (int32_t) NULL_WORD);
712 __ jcc(Assembler::equal, oop_empty);
713 __ stop("exception oop already set");
714 __ bind(oop_empty);
717 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), 0);
718 __ jcc(Assembler::equal, pc_empty);
719 __ stop("exception pc already set");
720 __ bind(pc_empty);
725 __ movptr(Address(thread, JavaThread::exception_oop_offset()), exception_oop);
726 __ movptr(Address(thread, JavaThread::exception_pc_offset()), exception_pc);
729 __ movptr(Address(rbp, 1*BytesPerWord), exception_pc);
733 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
741 __ invalidate_registers(false, true, true, true, true, true);
744 __ movptr(Address(rbp, 1*BytesPerWord), rax);
758 __ leave();
759 __ pop(rcx);
762 NOT_LP64(__ get_thread(thread);)
763 __ cmpl(Address(thread, JavaThread::is_method_handle_return_offset()), 0);
764 __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
765 __ jmp(rcx); // jump to exception handler
785 __ invalidate_registers(false, true, true, true, true, true);
789 NOT_LP64(__ get_thread(thread);)
791 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), 0);
792 __ jcc(Assembler::equal, oop_empty);
793 __ stop("exception oop must be empty");
794 __ bind(oop_empty);
797 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), 0);
798 __ jcc(Assembler::equal, pc_empty);
799 __ stop("exception pc must be empty");
800 __ bind(pc_empty);
804 __ empty_FPU_stack();
807 __ verify_not_null_oop(exception_oop);
808 __ movptr(exception_oop_callee_saved, exception_oop);
810 NOT_LP64(__ get_thread(thread);)
812 __ movptr(exception_pc, Address(rsp, 0));
815 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, exception_pc);
819 __ invalidate_registers(false, true, true, true, false, true);
822 __ movptr(handler_addr, rax);
825 __ movptr(exception_oop, exception_oop_callee_saved);
828 __ verify_not_null_oop(exception_oop);
833 __ pop(exception_pc);
836 NOT_LP64(__ get_thread(thread);)
837 __ cmpl(Address(thread, JavaThread::is_method_handle_return_offset()), 0);
838 __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
849 __ jmp(handler_addr);
868 __ mov(c_rarg0, thread);
870 __ push(rax); // push dummy
874 __ get_thread(thread);
875 __ push(thread);
877 __ set_last_Java_frame(thread, noreg, rbp, NULL);
879 __ call(RuntimeAddress(target));
881 oop_maps->add_gc_map(__ offset(), oop_map);
885 __ push(rax);
887 __ get_thread(rax);
888 __ cmpptr(thread, rax);
889 __ jcc(Assembler::equal, L);
890 __ stop("StubAssembler::call_RT: rdi/r15 not callee saved?");
891 __ bind(L);
893 __ pop(rax);
895 __ reset_last_Java_frame(thread, true, false);
897 __ pop(rcx); // discard thread arg
898 __ pop(rcx); // discard dummy
903 __ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
904 __ jcc(Assembler::equal, L);
907 __ testptr(rax, rax); // have we deoptimized?
908 __ jump_cc(Assembler::equal,
915 __ movptr(rax, Address(thread, Thread::pending_exception_offset()));
916 __ movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
919 __ verify_not_null_oop(rax);
922 __ movptr(rdx, Address(rsp, return_off * VMRegImpl::stack_slot_size));
927 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), (int32_t)NULL_WORD);
928 __ jcc(Assembler::equal, oop_empty);
929 __ stop("exception oop must be empty");
930 __ bind(oop_empty);
933 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), (int32_t)NULL_WORD);
934 __ jcc(Assembler::equal, pc_empty);
935 __ stop("exception pc must be empty");
936 __ bind(pc_empty);
940 __ movptr(Address(thread, JavaThread::exception_oop_offset()), rax);
941 __ movptr(Address(thread, JavaThread::exception_pc_offset()), rdx);
945 __ leave();
946 __ addptr(rsp, BytesPerWord); // remove return address from stack
952 __ jump(RuntimeAddress(deopt_blob->unpack_with_exception_in_tls()));
954 __ bind(L);
963 __ testptr(rax, rax); // have we deoptimized?
964 __ jcc(Assembler::equal, cont); // no
969 __ leave();
970 __ jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
972 __ bind(cont);
974 __ leave();
975 __ ret(0);
996 __ leave();
997 __ ret(0);
1009 __ set_info("new_instance", dont_gc_arguments);
1011 __ set_info("fast new_instance", dont_gc_arguments);
1014 __ set_info("fast new_instance init check", dont_gc_arguments);
1025 __ push(rdi);
1026 __ push(rbx);
1030 __ cmpb(Address(klass, instanceKlass::init_state_offset()), instanceKlass::fully_initialized);
1031 __ jcc(Assembler::notEqual, slow_path);
1038 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
1039 __ cmpl(obj_size, 0); // make sure it's an instance (LH > 0)
1040 __ jcc(Assembler::lessEqual, not_ok);
1041 __ testl(obj_size, Klass::_lh_instance_slow_path_bit);
1042 __ jcc(Assembler::zero, ok);
1043 __ bind(not_ok);
1044 __ stop("assert(can be fast path allocated)");
1045 __ should_not_reach_here();
1046 __ bind(ok);
1054 __ tlab_refill(retry_tlab, try_eden, slow_path); // does not destroy rdx (klass), returns rdi
1056 __ bind(retry_tlab);
1059 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
1061 __ tlab_allocate(obj, obj_size, 0, t1, t2, slow_path);
1063 __ initialize_object(obj, klass, obj_size, 0, t1, t2);
1064 __ verify_oop(obj);
1065 __ pop(rbx);
1066 __ pop(rdi);
1067 __ ret(0);
1069 __ bind(try_eden);
1071 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
1073 __ eden_allocate(obj, obj_size, 0, t1, slow_path);
1074 __ incr_allocated_bytes(thread, obj_size, 0);
1076 __ initialize_object(obj, klass, obj_size, 0, t1, t2);
1077 __ verify_oop(obj);
1078 __ pop(rbx);
1079 __ pop(rdi);
1080 __ ret(0);
1082 __ bind(slow_path);
1083 __ pop(rbx);
1084 __ pop(rdi);
1087 __ enter();
1089 int call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_instance), klass);
1093 __ verify_oop(obj);
1094 __ leave();
1095 __ ret(0);
1105 __ enter();
1108 __ movl(bci, Address(rbp, 2*BytesPerWord));
1110 __ movptr(method, Address(rbp, 3*BytesPerWord));
1111 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci, method);
1115 __ leave();
1116 __ ret(0);
1128 __ set_info("new_type_array", dont_gc_arguments);
1130 __ set_info("new_object_array", dont_gc_arguments);
1138 __ movl(t0, Address(klass, Klass::layout_helper_offset()));
1139 __ sarl(t0, Klass::_lh_array_tag_shift);
1143 __ cmpl(t0, tag);
1144 __ jcc(Assembler::equal, ok);
1145 __ stop("assert(is an array klass)");
1146 __ should_not_reach_here();
1147 __ bind(ok);
1159 __ cmpl(length, C1_MacroAssembler::max_array_allocation_length);
1160 __ jcc(Assembler::above, slow_path);
1166 __ tlab_refill(retry_tlab, try_eden, slow_path); // preserves rbx & rdx, returns rdi
1168 __ bind(retry_tlab);
1172 __ movl(t1, Address(klass, Klass::layout_helper_offset()));
1174 __ movl(arr_size, length);
1176 __ shlptr(arr_size /* by t1=rcx, mod 32 */);
1177 __ shrptr(t1, Klass::_lh_header_size_shift);
1178 __ andptr(t1, Klass::_lh_header_size_mask);
1179 __ addptr(arr_size, t1);
1180 __ addptr(arr_size, MinObjAlignmentInBytesMask); // align up
1181 __ andptr(arr_size, ~MinObjAlignmentInBytesMask);
1183 __ tlab_allocate(obj, arr_size, 0, t1, t2, slow_path); // preserves arr_size
1185 __ initialize_header(obj, klass, length, t1, t2);
1186 __ movb(t1, Address(klass, in_bytes(Klass::layout_helper_offset()) + (Klass::_lh_header_size_shift / BitsPerByte)));
1189 __ andptr(t1, Klass::_lh_header_size_mask);
1190 __ subptr(arr_size, t1); // body length
1191 __ addptr(t1, obj); // body start
1192 __ initialize_body(t1, arr_size, 0, t2);
1193 __ verify_oop(obj);
1194 __ ret(0);
1196 __ bind(try_eden);
1199 __ movl(t1, Address(klass, Klass::layout_helper_offset()));
1201 __ movl(arr_size, length);
1203 __ shlptr(arr_size /* by t1=rcx, mod 32 */);
1204 __ shrptr(t1, Klass::_lh_header_size_shift);
1205 __ andptr(t1, Klass::_lh_header_size_mask);
1206 __ addptr(arr_size, t1);
1207 __ addptr(arr_size, MinObjAlignmentInBytesMask); // align up
1208 __ andptr(arr_size, ~MinObjAlignmentInBytesMask);
1210 __ eden_allocate(obj, arr_size, 0, t1, slow_path); // preserves arr_size
1211 __ incr_allocated_bytes(thread, arr_size, 0);
1213 __ initialize_header(obj, klass, length, t1, t2);
1214 __ movb(t1, Address(klass, in_bytes(Klass::layout_helper_offset()) + (Klass::_lh_header_size_shift / BitsPerByte)));
1217 __ andptr(t1, Klass::_lh_header_size_mask);
1218 __ subptr(arr_size, t1); // body length
1219 __ addptr(t1, obj); // body start
1220 __ initialize_body(t1, arr_size, 0, t2);
1221 __ verify_oop(obj);
1222 __ ret(0);
1224 __ bind(slow_path);
1227 __ enter();
1231 call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_type_array), klass, length);
1233 call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_object_array), klass, length);
1240 __ verify_oop(obj);
1241 __ leave();
1242 __ ret(0);
1254 int call_offset = __ call_RT(rax, noreg, CAST_FROM_FN_PTR(address, new_multi_array), rax, rbx, rcx);
1261 __ verify_oop(rax);
1267 __ set_info("register_finalizer", dont_gc_arguments);
1273 __ verify_oop(c_rarg0);
1274 __ mov(rax, c_rarg0);
1278 __ movptr(rax, Address(rsp, 1 * BytesPerWord));
1279 __ verify_oop(rax);
1285 __ load_klass(t, rax);
1286 __ movl(t, Address(t, Klass::access_flags_offset()));
1287 __ testl(t, JVM_ACC_HAS_FINALIZER);
1288 __ jcc(Assembler::notZero, register_finalizer);
1289 __ ret(0);
1291 __ bind(register_finalizer);
1292 __ enter();
1294 int call_offset = __ call_RT(noreg, noreg,
1302 __ leave();
1303 __ ret(0);
1345 { __ set_info("unwind_exception", dont_gc_arguments);
1375 // __ push(klass_RInfo); // object klass or other subclass
1376 // __ push(sup_k_RInfo); // array element klass or other superclass
1377 // __ call(slow_subtype_check);
1394 __ set_info("slow_subtype_check", dont_gc_arguments);
1395 __ push(rdi);
1396 __ push(rsi);
1397 __ push(rcx);
1398 __ push(rax);
1401 __ movptr(rsi, Address(rsp, (klass_off) * VMRegImpl::stack_slot_size)); // subclass
1402 __ movptr(rax, Address(rsp, (sup_k_off) * VMRegImpl::stack_slot_size)); // superclass
1405 __ check_klass_subtype_slow_path(rsi, rax, rcx, rdi, NULL, &miss);
1408 __ movptr(Address(rsp, (result_off) * VMRegImpl::stack_slot_size), 1); // result
1409 __ pop(rax);
1410 __ pop(rcx);
1411 __ pop(rsi);
1412 __ pop(rdi);
1413 __ ret(0);
1415 __ bind(miss);
1416 __ movptr(Address(rsp, (result_off) * VMRegImpl::stack_slot_size), NULL_WORD); // result
1417 __ pop(rax);
1418 __ pop(rcx);
1419 __ pop(rsi);
1420 __ pop(rdi);
1421 __ ret(0);
1438 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), rax, rbx);
1461 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), rax);
1474 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, deoptimize));
1480 __ leave();
1481 __ jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
1506 __ NOT_LP64(push(rax)) LP64_ONLY(mov(c_rarg0, rax));
1507 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc)));
1508 NOT_LP64(__ pop(rax));
1518 __ push(rsi);
1519 __ push(rcx);
1520 LP64_ONLY(__ push(rdx);)
1530 __ subptr(rsp, 32); // more than enough on 32bit
1531 __ fst_d(value_low_word);
1532 __ movl(rax, value_high_word);
1533 __ andl(rax, 0x7ff00000);
1534 __ cmpl(rax, 0x7ff00000);
1535 __ jcc(Assembler::notEqual, do_convert);
1536 __ movl(rax, value_high_word);
1537 __ andl(rax, 0xfffff);
1538 __ orl(rax, value_low_word);
1539 __ jcc(Assembler::notZero, return0);
1541 __ bind(do_convert);
1542 __ fnstcw(Address(rsp, 0));
1543 __ movzwl(rax, Address(rsp, 0));
1544 __ orl(rax, 0xc00);
1545 __ movw(Address(rsp, 2), rax);
1546 __ fldcw(Address(rsp, 2));
1547 __ fwait();
1548 __ fistp_d(result_low_word);
1549 __ fldcw(Address(rsp, 0));
1550 __ fwait();
1552 __ movptr(rax, result_low_word);
1554 __ movl(rdx, result_high_word);
1555 __ mov(rcx, rax);
1557 __ xorl(rcx, 0x0);
1558 __ movl(rsi, 0x80000000);
1559 __ xorl(rsi, rdx);
1560 __ orl(rcx, rsi);
1561 __ jcc(Assembler::notEqual, do_return);
1562 __ fldz();
1563 __ fcomp_d(value_low_word);
1564 __ fnstsw_ax();
1566 __ testl(rax, 0x4100); // ZF & CF == 0
1567 __ jcc(Assembler::equal, return_min_jlong);
1569 __ sahf();
1570 __ jcc(Assembler::above, return_min_jlong);
1574 __ movl(rdx, 0x7fffffff);
1575 __ movl(rax, 0xffffffff);
1577 __ mov64(rax, CONST64(0x7fffffffffffffff));
1579 __ jmp(do_return);
1581 __ bind(return_min_jlong);
1583 __ movl(rdx, 0x80000000);
1584 __ xorl(rax, rax);
1586 __ mov64(rax, CONST64(0x8000000000000000));
1588 __ jmp(do_return);
1590 __ bind(return0);
1591 __ fpop();
1593 __ xorptr(rdx,rdx);
1594 __ xorptr(rax,rax);
1596 __ xorptr(rax, rax);
1599 __ bind(do_return);
1600 __ addptr(rsp, 32);
1601 LP64_ONLY(__ pop(rdx);)
1602 __ pop(rcx);
1603 __ pop(rsi);
1604 __ ret(0);
1616 __ movptr(rax, (int)id);
1617 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
1618 __ should_not_reach_here();
1621 __ push(rax);
1622 __ push(rdx);
1628 NOT_LP64(__ get_thread(thread);)
1645 __ movslq(tmp, queue_index);
1646 __ cmpq(tmp, 0);
1648 __ cmpl(queue_index, 0);
1650 __ jcc(Assembler::equal, runtime);
1652 __ subq(tmp, wordSize);
1653 __ movl(queue_index, tmp);
1654 __ addq(tmp, buffer);
1656 __ subl(queue_index, wordSize);
1657 __ movl(tmp, buffer);
1658 __ addl(tmp, queue_index);
1663 __ movptr(Address(tmp, 0), pre_val);
1664 __ jmp(done);
1666 __ bind(runtime);
1667 __ push(rcx);
1669 __ push(r8);
1670 __ push(r9);
1671 __ push(r10);
1672 __ push(r11);
1674 __ push(rdi);
1675 __ push(rsi);
1680 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), rcx, thread);
1683 __ pop(rsi);
1684 __ pop(rdi);
1686 __ pop(r11);
1687 __ pop(r10);
1688 __ pop(r9);
1689 __ pop(r8);
1691 __ pop(rcx);
1692 __ bind(done);
1694 __ pop(rdx);
1695 __ pop(rax);
1722 __ push(rax);
1723 __ push(rcx);
1725 NOT_LP64(__ get_thread(thread);)
1733 __ shrq(card_addr, CardTableModRefBS::card_shift);
1734 __ lea(tmp, cardtable);
1736 __ addq(card_addr, tmp);
1740 __ shrl(card_index, CardTableModRefBS::card_shift);
1743 __ leal(card_addr, __ as_Address(ArrayAddress(cardtable, index)));
1746 __ cmpb(Address(card_addr, 0), 0);
1747 __ jcc(Assembler::equal, done);
1752 __ movb(Address(card_addr, 0), 0);
1754 __ cmpl(queue_index, 0);
1755 __ jcc(Assembler::equal, runtime);
1756 __ subl(queue_index, wordSize);
1759 __ push(rbx);
1761 __ movptr(buffer_addr, buffer);
1764 __ movslq(rscratch1, queue_index);
1765 __ addptr(buffer_addr, rscratch1);
1767 __ addptr(buffer_addr, queue_index);
1769 __ movptr(Address(buffer_addr, 0), card_addr);
1771 __ pop(rbx);
1772 __ jmp(done);
1774 __ bind(runtime);
1775 __ push(rdx);
1777 __ push(r8);
1778 __ push(r9);
1779 __ push(r10);
1780 __ push(r11);
1782 __ push(rdi);
1783 __ push(rsi);
1786 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), card_addr, thread);
1789 __ pop(rsi);
1790 __ pop(rdi);
1792 __ pop(r11);
1793 __ pop(r10);
1794 __ pop(r9);
1795 __ pop(r8);
1797 __ pop(rdx);
1798 __ bind(done);
1800 __ pop(rcx);
1801 __ pop(rax);
1809 __ movptr(rax, (int)id);
1810 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
1811 __ should_not_reach_here();
1818 #undef __