458 break;
459 }
460 case RegisterSaver::float_reg: {
461 if (as_FloatRegister(reg_num)==F1_RET) // float result_reg
462 __ lfd(as_FloatRegister(reg_num), offset, R1_SP);
463 break;
464 }
465 case RegisterSaver::special_reg: {
466 // Special registers don't hold a result.
467 break;
468 }
469 default:
470 ShouldNotReachHere();
471 }
472 offset += reg_size;
473 }
474 }
475
476 // Is vector's size (in bytes) bigger than a size saved by default?
477 bool SharedRuntime::is_wide_vector(int size) {
478 ResourceMark rm;
479 // Note, MaxVectorSize == 8 on PPC64.
480 assert(size <= 8, err_msg_res("%d bytes vectors are not supported", size));
481 return size > 8;
482 }
483 #ifdef COMPILER2
484 static int reg2slot(VMReg r) {
485 return r->reg2stack() + SharedRuntime::out_preserve_stack_slots();
486 }
487
488 static int reg2offset(VMReg r) {
489 return (r->reg2stack() + SharedRuntime::out_preserve_stack_slots()) * VMRegImpl::stack_slot_size;
490 }
491 #endif
492
493 // ---------------------------------------------------------------------------
494 // Read the array of BasicTypes from a signature, and compute where the
495 // arguments should go. Values in the VMRegPair regs array refer to 4-byte
496 // quantities. Values less than VMRegImpl::stack0 are registers, those above
497 // refer to 4-byte stack slots. All stack slots are based off of the stack pointer
498 // as framesizes are fixed.
499 // VMRegImpl::stack0 refers to the first slot 0(sp).
500 // and VMRegImpl::stack0+1 refers to the memory word 4-bytes higher. Register
1614 static void gen_special_dispatch(MacroAssembler* masm,
1615 methodHandle method,
1616 const BasicType* sig_bt,
1617 const VMRegPair* regs) {
1618 verify_oop_args(masm, method, sig_bt, regs);
1619 vmIntrinsics::ID iid = method->intrinsic_id();
1620
1621 // Now write the args into the outgoing interpreter space
1622 bool has_receiver = false;
1623 Register receiver_reg = noreg;
1624 int member_arg_pos = -1;
1625 Register member_reg = noreg;
1626 int ref_kind = MethodHandles::signature_polymorphic_intrinsic_ref_kind(iid);
1627 if (ref_kind != 0) {
1628 member_arg_pos = method->size_of_parameters() - 1; // trailing MemberName argument
1629 member_reg = R19_method; // known to be free at this point
1630 has_receiver = MethodHandles::ref_kind_has_receiver(ref_kind);
1631 } else if (iid == vmIntrinsics::_invokeBasic) {
1632 has_receiver = true;
1633 } else {
1634 fatal(err_msg_res("unexpected intrinsic id %d", iid));
1635 }
1636
1637 if (member_reg != noreg) {
1638 // Load the member_arg into register, if necessary.
1639 SharedRuntime::check_member_name_argument_is_last_argument(method, sig_bt, regs);
1640 VMReg r = regs[member_arg_pos].first();
1641 if (r->is_stack()) {
1642 __ ld(member_reg, reg2offset(r), R1_SP);
1643 } else {
1644 // no data motion is needed
1645 member_reg = r->as_Register();
1646 }
1647 }
1648
1649 if (has_receiver) {
1650 // Make sure the receiver is loaded into a register.
1651 assert(method->size_of_parameters() > 0, "oob");
1652 assert(sig_bt[0] == T_OBJECT, "receiver argument must be an object");
1653 VMReg r = regs[0].first();
1654 assert(r->is_valid(), "bad receiver arg");
|
458 break;
459 }
460 case RegisterSaver::float_reg: {
461 if (as_FloatRegister(reg_num)==F1_RET) // float result_reg
462 __ lfd(as_FloatRegister(reg_num), offset, R1_SP);
463 break;
464 }
465 case RegisterSaver::special_reg: {
466 // Special registers don't hold a result.
467 break;
468 }
469 default:
470 ShouldNotReachHere();
471 }
472 offset += reg_size;
473 }
474 }
475
476 // Is vector's size (in bytes) bigger than a size saved by default?
477 bool SharedRuntime::is_wide_vector(int size) {
478 // Note, MaxVectorSize == 8 on PPC64.
479 assert(size <= 8, "%d bytes vectors are not supported", size);
480 return size > 8;
481 }
482 #ifdef COMPILER2
483 static int reg2slot(VMReg r) {
484 return r->reg2stack() + SharedRuntime::out_preserve_stack_slots();
485 }
486
487 static int reg2offset(VMReg r) {
488 return (r->reg2stack() + SharedRuntime::out_preserve_stack_slots()) * VMRegImpl::stack_slot_size;
489 }
490 #endif
491
492 // ---------------------------------------------------------------------------
493 // Read the array of BasicTypes from a signature, and compute where the
494 // arguments should go. Values in the VMRegPair regs array refer to 4-byte
495 // quantities. Values less than VMRegImpl::stack0 are registers, those above
496 // refer to 4-byte stack slots. All stack slots are based off of the stack pointer
497 // as framesizes are fixed.
498 // VMRegImpl::stack0 refers to the first slot 0(sp).
499 // and VMRegImpl::stack0+1 refers to the memory word 4-bytes higher. Register
1613 static void gen_special_dispatch(MacroAssembler* masm,
1614 methodHandle method,
1615 const BasicType* sig_bt,
1616 const VMRegPair* regs) {
1617 verify_oop_args(masm, method, sig_bt, regs);
1618 vmIntrinsics::ID iid = method->intrinsic_id();
1619
1620 // Now write the args into the outgoing interpreter space
1621 bool has_receiver = false;
1622 Register receiver_reg = noreg;
1623 int member_arg_pos = -1;
1624 Register member_reg = noreg;
1625 int ref_kind = MethodHandles::signature_polymorphic_intrinsic_ref_kind(iid);
1626 if (ref_kind != 0) {
1627 member_arg_pos = method->size_of_parameters() - 1; // trailing MemberName argument
1628 member_reg = R19_method; // known to be free at this point
1629 has_receiver = MethodHandles::ref_kind_has_receiver(ref_kind);
1630 } else if (iid == vmIntrinsics::_invokeBasic) {
1631 has_receiver = true;
1632 } else {
1633 fatal("unexpected intrinsic id %d", iid);
1634 }
1635
1636 if (member_reg != noreg) {
1637 // Load the member_arg into register, if necessary.
1638 SharedRuntime::check_member_name_argument_is_last_argument(method, sig_bt, regs);
1639 VMReg r = regs[member_arg_pos].first();
1640 if (r->is_stack()) {
1641 __ ld(member_reg, reg2offset(r), R1_SP);
1642 } else {
1643 // no data motion is needed
1644 member_reg = r->as_Register();
1645 }
1646 }
1647
1648 if (has_receiver) {
1649 // Make sure the receiver is loaded into a register.
1650 assert(method->size_of_parameters() > 0, "oob");
1651 assert(sig_bt[0] == T_OBJECT, "receiver argument must be an object");
1652 VMReg r = regs[0].first();
1653 assert(r->is_valid(), "bad receiver arg");
|