src/cpu/x86/vm/sharedRuntime_x86_64.cpp

*** 516,525 ****
--- 516,606 ----
    }
  
    return round_to(stk_args, 2);
  }
  
+ // Same as java_calling_convention() but for multiple return
+ // values. There's no way to store them on the stack so if we don't
+ // have enough registers, multiple values can't be returned.
+ const uint SharedRuntime::java_return_convention_max_int = Argument::n_int_register_parameters_j+1;
+ const uint SharedRuntime::java_return_convention_max_float = Argument::n_float_register_parameters_j;
+ int SharedRuntime::java_return_convention(const BasicType *sig_bt,
+                                           VMRegPair *regs,
+                                           int total_args_passed) {
+   // Create the mapping between argument positions and
+   // registers.
+   static const Register INT_ArgReg[java_return_convention_max_int] = {
+     rax, j_rarg5, j_rarg4, j_rarg3, j_rarg2, j_rarg1, j_rarg0
+   };
+   static const XMMRegister FP_ArgReg[java_return_convention_max_float] = {
+     j_farg0, j_farg1, j_farg2, j_farg3,
+     j_farg4, j_farg5, j_farg6, j_farg7
+   };
+ 
+ 
+   uint int_args = 0;
+   uint fp_args = 0;
+ 
+   for (int i = 0; i < total_args_passed; i++) {
+     switch (sig_bt[i]) {
+     case T_BOOLEAN:
+     case T_CHAR:
+     case T_BYTE:
+     case T_SHORT:
+     case T_INT:
+       if (int_args < Argument::n_int_register_parameters_j+1) {
+         regs[i].set1(INT_ArgReg[int_args]->as_VMReg());
+         int_args++;
+       } else {
+         return -1;
+       }
+       break;
+     case T_VOID:
+       // halves of T_LONG or T_DOUBLE
+       assert(i != 0 && (sig_bt[i - 1] == T_LONG || sig_bt[i - 1] == T_DOUBLE), "expecting half");
+       regs[i].set_bad();
+       break;
+     case T_LONG:
+       assert(sig_bt[i + 1] == T_VOID, "expecting half");
+       // fall through
+     case T_OBJECT:
+     case T_ARRAY:
+     case T_ADDRESS:
+     case T_METADATA:
+       if (int_args < Argument::n_int_register_parameters_j+1) {
+         regs[i].set2(INT_ArgReg[int_args]->as_VMReg());
+         int_args++;
+       } else {
+         return -1;
+       }
+       break;
+     case T_FLOAT:
+       if (fp_args < Argument::n_float_register_parameters_j) {
+         regs[i].set1(FP_ArgReg[fp_args]->as_VMReg());
+         fp_args++;
+       } else {
+         return -1;
+       }
+       break;
+     case T_DOUBLE:
+       assert(sig_bt[i + 1] == T_VOID, "expecting half");
+       if (fp_args < Argument::n_float_register_parameters_j) {
+         regs[i].set2(FP_ArgReg[fp_args]->as_VMReg());
+         fp_args++;
+       } else {
+         return -1;
+       }
+       break;
+     default:
+       ShouldNotReachHere();
+       break;
+     }
+   }
+ 
+   return int_args + fp_args;
+ }
+ 
  // Patch the callers callsite with entry to compiled code if it exists.
  static void patch_callers_callsite(MacroAssembler *masm) {
    Label L;
    __ cmpptr(Address(rbx, in_bytes(Method::code_offset())), (int32_t)NULL_WORD);
    __ jcc(Assembler::equal, L);