jdk-sandbox: comparison hotspot/src/cpu/x86/vm/sharedRuntime_x86

equal deleted inserted replaced

-:7fd047780d47
+:a326d528f3e1
 simple_move32(masm, tmp, length_arg);
 __ bind(done);
 }
 static void verify_oop_args(MacroAssembler* masm,
-int total_args_passed,
+methodHandle method,
 const BasicType* sig_bt,
 const VMRegPair* regs) {
 Register temp_reg = rbx;  // not part of any compiled calling seq
 if (VerifyOops) {
-for (int i = 0; i < total_args_passed; i++) {
+for (int i = 0; i < method->size_of_parameters(); i++) {
 if (sig_bt[i] == T_OBJECT ||
 sig_bt[i] == T_ARRAY) {
 VMReg r = regs[i].first();
 assert(r->is_valid(), "bad oop arg");
 if (r->is_stack()) {
 }
 }
 }
 static void gen_special_dispatch(MacroAssembler* masm,
-int total_args_passed,
+methodHandle method,
-int comp_args_on_stack,
-vmIntrinsics::ID special_dispatch,
 const BasicType* sig_bt,
 const VMRegPair* regs) {
-verify_oop_args(masm, total_args_passed, sig_bt, regs);
+verify_oop_args(masm, method, sig_bt, regs);
+vmIntrinsics::ID iid = method->intrinsic_id();
 // Now write the args into the outgoing interpreter space
 bool     has_receiver   = false;
 Register receiver_reg   = noreg;
 int      member_arg_pos = -1;
 Register member_reg     = noreg;
-int      ref_kind       = MethodHandles::signature_polymorphic_intrinsic_ref_kind(special_dispatch);
+int      ref_kind       = MethodHandles::signature_polymorphic_intrinsic_ref_kind(iid);
 if (ref_kind != 0) {
-member_arg_pos = total_args_passed - 1;  // trailing MemberName argument
+member_arg_pos = method->size_of_parameters() - 1;  // trailing MemberName argument
 member_reg = rbx;  // known to be free at this point
 has_receiver = MethodHandles::ref_kind_has_receiver(ref_kind);
-} else if (special_dispatch == vmIntrinsics::_invokeBasic) {
+} else if (iid == vmIntrinsics::_invokeBasic) {
 has_receiver = true;
 } else {
-guarantee(false, err_msg("special_dispatch=%d", special_dispatch));
+fatal(err_msg_res("unexpected intrinsic id %d", iid));
 }
 if (member_reg != noreg) {
 // Load the member_arg into register, if necessary.
-assert(member_arg_pos >= 0 && member_arg_pos < total_args_passed, "oob");
+SharedRuntime::check_member_name_argument_is_last_argument(method, sig_bt, regs);
-assert(sig_bt[member_arg_pos] == T_OBJECT, "dispatch argument must be an object");
 VMReg r = regs[member_arg_pos].first();
-assert(r->is_valid(), "bad member arg");
 if (r->is_stack()) {
 __ movptr(member_reg, Address(rsp, r->reg2stack() * VMRegImpl::stack_slot_size + wordSize));
 } else {
 // no data motion is needed
 member_reg = r->as_Register();
 }
 }
 if (has_receiver) {
 // Make sure the receiver is loaded into a register.
-assert(total_args_passed > 0, "oob");
+assert(method->size_of_parameters() > 0, "oob");
 assert(sig_bt[0] == T_OBJECT, "receiver argument must be an object");
 VMReg r = regs[0].first();
 assert(r->is_valid(), "bad receiver arg");
 if (r->is_stack()) {
 // Porting note:  This assumes that compiled calling conventions always
 // pass the receiver oop in a register.  If this is not true on some
 // platform, pick a temp and load the receiver from stack.
-assert(false, "receiver always in a register");
+fatal("receiver always in a register");
 receiver_reg = rcx;  // known to be free at this point
 __ movptr(receiver_reg, Address(rsp, r->reg2stack() * VMRegImpl::stack_slot_size + wordSize));
 } else {
 // no data motion is needed
 receiver_reg = r->as_Register();
 }
 }
 // Figure out which address we are really jumping to:
-MethodHandles::generate_method_handle_dispatch(masm, special_dispatch,
+MethodHandles::generate_method_handle_dispatch(masm, iid,
 receiver_reg, member_reg, /*for_compiler_entry:*/ true);
 }
 // ---------------------------------------------------------------------------
 // Generate a native wrapper for a given method.  The method takes arguments
 //    return to caller
 //
 nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
 methodHandle method,
 int compile_id,
-int total_in_args,
-int comp_args_on_stack,
 BasicType* in_sig_bt,
 VMRegPair* in_regs,
 BasicType ret_type) {
 if (method->is_method_handle_intrinsic()) {
 vmIntrinsics::ID iid = method->intrinsic_id();
 intptr_t start = (intptr_t)__ pc();
 int vep_offset = ((intptr_t)__ pc()) - start;
 gen_special_dispatch(masm,
-total_in_args,
+method,
-comp_args_on_stack,
-method->intrinsic_id(),
 in_sig_bt,
 in_regs);
 int frame_complete = ((intptr_t)__ pc()) - start;  // not complete, period
 __ flush();
 int stack_slots = SharedRuntime::out_preserve_stack_slots();  // no out slots at all, actually
 // on entry to the wrapper. We need to convert these args to where
 // the jni function will expect them. To figure out where they go
 // we convert the java signature to a C signature by inserting
 // the hidden arguments as arg[0] and possibly arg[1] (static method)
+const int total_in_args = method->size_of_parameters();
 int total_c_args = total_in_args;
 if (!is_critical_native) {
 total_c_args += 1;
 if (method->is_static()) {
 total_c_args++;

changeset 13881	a326d528f3e1
parent 13742	9180987e305d
child 13883	6979b9850feb