501 }
502 break;
503 case T_DOUBLE:
504 assert((i + 1) < total_args_passed && sig_bt[i + 1] == T_VOID, "expecting half");
505 if (fp_args < Argument::n_float_register_parameters_j) {
506 regs[i].set2(FP_ArgReg[fp_args++]->as_VMReg());
507 } else {
508 regs[i].set2(VMRegImpl::stack2reg(stk_args));
509 stk_args += 2;
510 }
511 break;
512 default:
513 ShouldNotReachHere();
514 break;
515 }
516 }
517
518 return round_to(stk_args, 2);
519 }
520
521 // Patch the callers callsite with entry to compiled code if it exists.
522 static void patch_callers_callsite(MacroAssembler *masm) {
523 Label L;
524 __ cmpptr(Address(rbx, in_bytes(Method::code_offset())), (int32_t)NULL_WORD);
525 __ jcc(Assembler::equal, L);
526
527 // Save the current stack pointer
528 __ mov(r13, rsp);
529 // Schedule the branch target address early.
530 // Call into the VM to patch the caller, then jump to compiled callee
531 // rax isn't live so capture return address while we easily can
532 __ movptr(rax, Address(rsp, 0));
533
534 // align stack so push_CPU_state doesn't fault
535 __ andptr(rsp, -(StackAlignmentInBytes));
536 __ push_CPU_state();
537 __ vzeroupper();
538 // VM needs caller's callsite
539 // VM needs target method
540 // This needs to be a long call since we will relocate this adapter to
|
501 }
502 break;
503 case T_DOUBLE:
504 assert((i + 1) < total_args_passed && sig_bt[i + 1] == T_VOID, "expecting half");
505 if (fp_args < Argument::n_float_register_parameters_j) {
506 regs[i].set2(FP_ArgReg[fp_args++]->as_VMReg());
507 } else {
508 regs[i].set2(VMRegImpl::stack2reg(stk_args));
509 stk_args += 2;
510 }
511 break;
512 default:
513 ShouldNotReachHere();
514 break;
515 }
516 }
517
518 return round_to(stk_args, 2);
519 }
520
521 // Same as java_calling_convention() but for multiple return
522 // values. There's no way to store them on the stack so if we don't
523 // have enough registers, multiple values can't be returned.
524 const uint SharedRuntime::java_return_convention_max_int = Argument::n_int_register_parameters_j+1;
525 const uint SharedRuntime::java_return_convention_max_float = Argument::n_float_register_parameters_j;
526 int SharedRuntime::java_return_convention(const BasicType *sig_bt,
527 VMRegPair *regs,
528 int total_args_passed) {
529 // Create the mapping between argument positions and
530 // registers.
531 static const Register INT_ArgReg[java_return_convention_max_int] = {
532 rax, j_rarg5, j_rarg4, j_rarg3, j_rarg2, j_rarg1, j_rarg0
533 };
534 static const XMMRegister FP_ArgReg[java_return_convention_max_float] = {
535 j_farg0, j_farg1, j_farg2, j_farg3,
536 j_farg4, j_farg5, j_farg6, j_farg7
537 };
538
539
540 uint int_args = 0;
541 uint fp_args = 0;
542
543 for (int i = 0; i < total_args_passed; i++) {
544 switch (sig_bt[i]) {
545 case T_BOOLEAN:
546 case T_CHAR:
547 case T_BYTE:
548 case T_SHORT:
549 case T_INT:
550 if (int_args < Argument::n_int_register_parameters_j+1) {
551 regs[i].set1(INT_ArgReg[int_args]->as_VMReg());
552 int_args++;
553 } else {
554 return -1;
555 }
556 break;
557 case T_VOID:
558 // halves of T_LONG or T_DOUBLE
559 assert(i != 0 && (sig_bt[i - 1] == T_LONG || sig_bt[i - 1] == T_DOUBLE), "expecting half");
560 regs[i].set_bad();
561 break;
562 case T_LONG:
563 assert(sig_bt[i + 1] == T_VOID, "expecting half");
564 // fall through
565 case T_OBJECT:
566 case T_ARRAY:
567 case T_ADDRESS:
568 case T_METADATA:
569 if (int_args < Argument::n_int_register_parameters_j+1) {
570 regs[i].set2(INT_ArgReg[int_args]->as_VMReg());
571 int_args++;
572 } else {
573 return -1;
574 }
575 break;
576 case T_FLOAT:
577 if (fp_args < Argument::n_float_register_parameters_j) {
578 regs[i].set1(FP_ArgReg[fp_args]->as_VMReg());
579 fp_args++;
580 } else {
581 return -1;
582 }
583 break;
584 case T_DOUBLE:
585 assert(sig_bt[i + 1] == T_VOID, "expecting half");
586 if (fp_args < Argument::n_float_register_parameters_j) {
587 regs[i].set2(FP_ArgReg[fp_args]->as_VMReg());
588 fp_args++;
589 } else {
590 return -1;
591 }
592 break;
593 default:
594 ShouldNotReachHere();
595 break;
596 }
597 }
598
599 return int_args + fp_args;
600 }
601
602 // Patch the callers callsite with entry to compiled code if it exists.
603 static void patch_callers_callsite(MacroAssembler *masm) {
604 Label L;
605 __ cmpptr(Address(rbx, in_bytes(Method::code_offset())), (int32_t)NULL_WORD);
606 __ jcc(Assembler::equal, L);
607
608 // Save the current stack pointer
609 __ mov(r13, rsp);
610 // Schedule the branch target address early.
611 // Call into the VM to patch the caller, then jump to compiled callee
612 // rax isn't live so capture return address while we easily can
613 __ movptr(rax, Address(rsp, 0));
614
615 // align stack so push_CPU_state doesn't fault
616 __ andptr(rsp, -(StackAlignmentInBytes));
617 __ push_CPU_state();
618 __ vzeroupper();
619 // VM needs caller's callsite
620 // VM needs target method
621 // This needs to be a long call since we will relocate this adapter to
|