src/cpu/x86/vm/x86_64.ad

rev 1082 : [mq]: indy.compiler.patch

*** 549,564 ****
  #define   RELOC_IMM64    Assembler::imm_operand
  #define   RELOC_DISP32   Assembler::disp32_operand
  
  #define __ _masm.
  
  // !!!!! Special hack to get all types of calls to specify the byte offset
  //       from the start of the call to the point where the return address
  //       will point.
  int MachCallStaticJavaNode::ret_addr_offset()
  {
!   return 5; // 5 bytes from start of call to where return address points
  }
  
  int MachCallDynamicJavaNode::ret_addr_offset()
  {
    return 15; // 15 bytes from start of call to where return address points
--- 549,571 ----
  #define   RELOC_IMM64    Assembler::imm_operand
  #define   RELOC_DISP32   Assembler::disp32_operand
  
  #define __ _masm.
  
+ static int preserve_SP_size() {
+   return LP64_ONLY(1 +) 2;  // [rex,] op, rm(reg/reg)
+ }
+ 
  // !!!!! Special hack to get all types of calls to specify the byte offset
  //       from the start of the call to the point where the return address
  //       will point.
  int MachCallStaticJavaNode::ret_addr_offset()
  {
!   int offset = 5; // 5 bytes from start of call to where return address points
!   if (_method_handle_invoke)
!     offset += preserve_SP_size();
!   return offset;
  }
  
  int MachCallDynamicJavaNode::ret_addr_offset()
  {
    return 15; // 15 bytes from start of call to where return address points
*** 587,596 ****
--- 594,612 ----
    return round_to(current_offset, alignment_required()) - current_offset;
  }
  
  // The address of the call instruction needs to be 4-byte aligned to
  // ensure that it does not span a cache line so that it can be patched.
+ int CallStaticJavaHandleNode::compute_padding(int current_offset) const
+ {
+   current_offset += preserve_SP_size();   // skip mov rbp, rsp
+   current_offset += 1; // skip call opcode byte
+   return round_to(current_offset, alignment_required()) - current_offset;
+ }
+ 
+ // The address of the call instruction needs to be 4-byte aligned to
+ // ensure that it does not span a cache line so that it can be patched.
  int CallDynamicJavaDirectNode::compute_padding(int current_offset) const
  {
    current_offset += 11; // skip movq instruction + call opcode byte
    return round_to(current_offset, alignment_required()) - current_offset;
  }
*** 2111,2120 ****
--- 2127,2140 ----
  // Register for MODL projection of divmodL
  RegMask Matcher::modL_proj_mask() {
    return LONG_RDX_REG_mask;
  }
  
+ const RegMask Matcher::method_handle_invoke_SP_save_mask() {
+   return PTR_RBP_REG_mask;
+ }
+ 
  static Address build_address(int b, int i, int s, int d) {
    Register index = as_Register(i);
    Address::ScaleFactor scale = (Address::ScaleFactor)s;
    if (index == rsp) {
      index = noreg;
*** 2606,2615 ****
--- 2626,2650 ----
                     (int) ($meth$$method - ((intptr_t) cbuf.code_end()) - 4),
                     runtime_call_Relocation::spec(),
                     RELOC_DISP32);
    %}
  
+   enc_class preserve_SP %{
+     debug_only(int off0 = cbuf.code_size());
+     MacroAssembler _masm(&cbuf);
+     // RBP is preserved across all calls, even compiled calls.
+     // Use it to preserve RSP in places where the callee might change the SP.
+     __ movptr(rbp, rsp);
+     debug_only(int off1 = cbuf.code_size());
+     assert(off1 - off0 == preserve_SP_size(), "correct size prediction");
+   %}
+ 
+   enc_class restore_SP %{
+     MacroAssembler _masm(&cbuf);
+     __ movptr(rsp, rbp);
+   %}
+ 
    enc_class Java_Static_Call(method meth)
    %{
      // JAVA STATIC CALL
      // CALL to fixup routine.  Fixup routine uses ScopeDesc info to
      // determine who we intended to call.
*** 12524,12536 ****
  // ============================================================================
  // Procedure Call/Return Instructions
  // Call Java Static Instruction
  // Note: If this code changes, the corresponding ret_addr_offset() and
  //       compute_padding() functions will have to be adjusted.
! instruct CallStaticJavaDirect(method meth)
! %{
    match(CallStaticJava);
    effect(USE meth);
  
    ins_cost(300);
    format %{ "call,static " %}
    opcode(0xE8); /* E8 cd */
--- 12559,12571 ----
  // ============================================================================
  // Procedure Call/Return Instructions
  // Call Java Static Instruction
  // Note: If this code changes, the corresponding ret_addr_offset() and
  //       compute_padding() functions will have to be adjusted.
! instruct CallStaticJavaDirect(method meth) %{
    match(CallStaticJava);
+   predicate(!((CallStaticJavaNode*) n)->is_method_handle_invoke());
    effect(USE meth);
  
    ins_cost(300);
    format %{ "call,static " %}
    opcode(0xE8); /* E8 cd */
*** 12538,12547 ****
--- 12573,12604 ----
    ins_pipe(pipe_slow);
    ins_pc_relative(1);
    ins_alignment(4);
  %}
  
+ // Call Java Static Instruction (method handle version)
+ // Note: If this code changes, the corresponding ret_addr_offset() and
+ //       compute_padding() functions will have to be adjusted.
+ instruct CallStaticJavaHandle(method meth, rbp_RegP rbp) %{
+   match(CallStaticJava);
+   predicate(((CallStaticJavaNode*) n)->is_method_handle_invoke());
+   effect(USE meth);
+   // RBP is saved by all callees (for interpreter stack correction).
+   // We use it here for a similar purpose, in {preserve,restore}_SP.
+ 
+   ins_cost(300);
+   format %{ "call,static MethodHandle " %}
+   opcode(0xE8); /* E8 cd */
+   ins_encode(preserve_SP,
+              Java_Static_Call(meth),
+              restore_SP,
+              call_epilog);
+   ins_pipe(pipe_slow);
+   ins_pc_relative(1);
+   ins_alignment(4);
+ %}
+ 
  // Call Java Dynamic Instruction
  // Note: If this code changes, the corresponding ret_addr_offset() and
  //       compute_padding() functions will have to be adjusted.
  instruct CallDynamicJavaDirect(method meth)
  %{