src/cpu/x86/vm/compiledIC_x86.cpp

*** 22,31 ****
--- 22,32 ----
   *
   */
  
  #include "precompiled.hpp"
  #include "asm/macroAssembler.inline.hpp"
+ #include "code/codeCache.hpp"
  #include "code/compiledIC.hpp"
  #include "code/icBuffer.hpp"
  #include "code/nmethod.hpp"
  #include "memory/resourceArea.hpp"
  #include "runtime/mutexLocker.hpp"
*** 51,61 ****
    address base = __ start_a_stub(to_interp_stub_size());
    if (base == NULL) {
      return NULL;  // CodeBuffer::expand failed.
    }
    // Static stub relocation stores the instruction address of the call.
!   __ relocate(static_stub_Relocation::spec(mark), Assembler::imm_operand);
    // Static stub relocation also tags the Method* in the code-stream.
    __ mov_metadata(rbx, (Metadata*) NULL);  // Method is zapped till fixup time.
    // This is recognized as unresolved by relocs/nativeinst/ic code.
    __ jump(RuntimeAddress(__ pc()));
  
--- 52,62 ----
    address base = __ start_a_stub(to_interp_stub_size());
    if (base == NULL) {
      return NULL;  // CodeBuffer::expand failed.
    }
    // Static stub relocation stores the instruction address of the call.
!   __ relocate(static_stub_Relocation::spec(mark, false), Assembler::imm_operand);
    // Static stub relocation also tags the Method* in the code-stream.
    __ mov_metadata(rbx, (Metadata*) NULL);  // Method is zapped till fixup time.
    // This is recognized as unresolved by relocs/nativeinst/ic code.
    __ jump(RuntimeAddress(__ pc()));
  
*** 75,91 ****
  // Relocation entries for call stub, compiled java to interpreter.
  int CompiledStaticCall::reloc_to_interp_stub() {
    return 4; // 3 in emit_to_interp_stub + 1 in emit_call
  }
  
! void CompiledStaticCall::set_to_interpreted(methodHandle callee, address entry) {
!   address stub = find_stub();
    guarantee(stub != NULL, "stub not found");
  
    if (TraceICs) {
      ResourceMark rm;
!     tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
                    p2i(instruction_address()),
                    callee->name_and_sig_as_C_string());
    }
  
    // Creation also verifies the object.
--- 76,152 ----
  // Relocation entries for call stub, compiled java to interpreter.
  int CompiledStaticCall::reloc_to_interp_stub() {
    return 4; // 3 in emit_to_interp_stub + 1 in emit_call
  }
  
! #if INCLUDE_AOT
! #define __ _masm.
! void CompiledStaticCall::emit_to_aot_stub(CodeBuffer &cbuf, address mark) {
!   if (!UseAOT) {
!     return;
!   }
!   // Stub is fixed up when the corresponding call is converted from
!   // calling compiled code to calling aot code.
!   // movq rax, imm64_aot_code_address
!   // jmp  rax
! 
!   if (mark == NULL) {
!     mark = cbuf.insts_mark();  // Get mark within main instrs section.
!   }
! 
!   // Note that the code buffer's insts_mark is always relative to insts.
!   // That's why we must use the macroassembler to generate a stub.
!   MacroAssembler _masm(&cbuf);
! 
!   address base =
!   __ start_a_stub(to_aot_stub_size());
!   guarantee(base != NULL, "out of space");
! 
!   // Static stub relocation stores the instruction address of the call.
!   __ relocate(static_stub_Relocation::spec(mark, true /* is_aot */), Assembler::imm_operand);
!   // Load destination AOT code address.
! #ifdef _LP64
!   __ mov64(rax, CONST64(0));  // address is zapped till fixup time.
! #else
!   __ movl(rax, 0);  // address is zapped till fixup time.
! #endif
!   // This is recognized as unresolved by relocs/nativeinst/ic code.
!   __ jmp(rax);
! 
!   assert(__ pc() - base <= to_aot_stub_size(), "wrong stub size");
! 
!   // Update current stubs pointer and restore insts_end.
!   __ end_a_stub();
! }
! #undef __
! 
! int CompiledStaticCall::to_aot_stub_size() {
!   if (UseAOT) {
!     return NOT_LP64(7)    // movl; jmp
!            LP64_ONLY(12);  // movq (1+1+8); jmp (2)
!   } else {
!     return 0;
!   }
! }
! 
! // Relocation entries for call stub, compiled java to aot.
! int CompiledStaticCall::reloc_to_aot_stub() {
!   if (UseAOT) {
!     return 2; // 1 in emit_to_aot_stub + 1 in emit_call
!   } else {
!     return 0;
!   }
! }
! #endif // INCLUDE_AOT
! 
! void CompiledDirectStaticCall::set_to_interpreted(methodHandle callee, address entry) {
!   address stub = find_stub(false /* is_aot */);
    guarantee(stub != NULL, "stub not found");
  
    if (TraceICs) {
      ResourceMark rm;
!     tty->print_cr("CompiledDirectStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
                    p2i(instruction_address()),
                    callee->name_and_sig_as_C_string());
    }
  
    // Creation also verifies the object.
*** 108,143 ****
  
    // Update jump to call.
    set_destination_mt_safe(stub);
  }
  
! void CompiledStaticCall::set_stub_to_clean(static_stub_Relocation* static_stub) {
    assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
    // Reset stub.
    address stub = static_stub->addr();
    assert(stub != NULL, "stub not found");
    // Creation also verifies the object.
    NativeMovConstReg* method_holder = nativeMovConstReg_at(stub);
    method_holder->set_data(0);
    NativeJump* jump = nativeJump_at(method_holder->next_instruction_address());
    jump->set_jump_destination((address)-1);
  }
  
  
  //-----------------------------------------------------------------------------
  // Non-product mode code
  #ifndef PRODUCT
  
! void CompiledStaticCall::verify() {
    // Verify call.
!   NativeCall::verify();
    if (os::is_MP()) {
!     verify_alignment();
    }
  
    // Verify stub.
!   address stub = find_stub();
    assert(stub != NULL, "no stub found for static call");
    // Creation also verifies the object.
    NativeMovConstReg* method_holder = nativeMovConstReg_at(stub);
    NativeJump*        jump          = nativeJump_at(method_holder->next_instruction_address());
  
--- 169,211 ----
  
    // Update jump to call.
    set_destination_mt_safe(stub);
  }
  
! void CompiledDirectStaticCall::set_stub_to_clean(static_stub_Relocation* static_stub) {
    assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
    // Reset stub.
    address stub = static_stub->addr();
    assert(stub != NULL, "stub not found");
    // Creation also verifies the object.
    NativeMovConstReg* method_holder = nativeMovConstReg_at(stub);
    method_holder->set_data(0);
+   if (!static_stub->is_aot()) {
      NativeJump* jump = nativeJump_at(method_holder->next_instruction_address());
      jump->set_jump_destination((address)-1);
+   }
  }
  
  
  //-----------------------------------------------------------------------------
  // Non-product mode code
  #ifndef PRODUCT
  
! void CompiledDirectStaticCall::verify() {
    // Verify call.
!   _call->verify();
    if (os::is_MP()) {
!     _call->verify_alignment();
    }
  
+ #ifdef ASSERT
+   CodeBlob *cb = CodeCache::find_blob_unsafe((address) _call);
+   assert(cb && !cb->is_aot(), "CompiledDirectStaticCall cannot be used on AOTCompiledMethod");
+ #endif
+ 
    // Verify stub.
!   address stub = find_stub(false /* is_aot */);
    assert(stub != NULL, "no stub found for static call");
    // Creation also verifies the object.
    NativeMovConstReg* method_holder = nativeMovConstReg_at(stub);
    NativeJump*        jump          = nativeJump_at(method_holder->next_instruction_address());