*** old/src/cpu/x86/vm/compiledIC_x86.cpp	Thu Nov  3 14:16:02 2016
--- new/src/cpu/x86/vm/compiledIC_x86.cpp	Thu Nov  3 14:16:02 2016

*** 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 ****
--- 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 ****
--- 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
  }
  
  void CompiledStaticCall::set_to_interpreted(methodHandle callee, address entry) {
    address stub = find_stub();
+ #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(const methodHandle& callee, address entry) {
+   address stub = find_stub(false /* is_aot */);
    guarantee(stub != NULL, "stub not found");
  
    if (TraceICs) {
      ResourceMark rm;
!     tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
!     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 ****
--- 169,211 ----
  
    // Update jump to call.
    set_destination_mt_safe(stub);
  }
  
! void CompiledStaticCall::set_stub_to_clean(static_stub_Relocation* static_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 CompiledStaticCall::verify() {
! void CompiledDirectStaticCall::verify() {
    // Verify call.
!   NativeCall::verify();
!   _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());