src/cpu/x86/vm/x86_32.ad

rev 4449 : 8003853: specify offset of IC load in java_to_interp stub

If a compiled static call calls the interpreter, it jumps past a
java_to_interp stub in the compiled code. Patching this call must
find the load of the IC. So far the shared code assumed this is the
first instruction in the stub.
This might not be the case if, for example, the base of the constant
table must be loaded as it happens on PPC.  The position of the IC
load is platform dependent, but used in shared code.

To fix this, this change cleans up the code handling compiled static
Java calls:
 - Methods using native instructions are moved from compiledIC.cpp
   to compiledIC_<cpu>.cpp
   With this the offset can be implemented platform dependent.
 - Methods emitting the stub moved from the ad file to this class.
   As a side effect this reduces redundancies in x86_64.ad and x86_32.ad.
 - We get rid of extern declarations in output.cpp.

Now all code concerning CompiledStaticCalls is collected on one class,
except for emitting the call itself.  The PPC port needs not change
shared code any more to implement them.

*** 1255,1301 ****
      return 4;
    }
  }
  
  //=============================================================================
- 
- // emit call stub, compiled java to interpreter
- void emit_java_to_interp(CodeBuffer &cbuf ) {
-   // Stub is fixed up when the corresponding call is converted from calling
-   // compiled code to calling interpreted code.
-   // mov rbx,0
-   // jmp -1
- 
-   address 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(Compile::MAX_stubs_size);
-   if (base == NULL)  return;  // CodeBuffer::expand failed
-   // static stub relocation stores the instruction address of the call
-   __ relocate(static_stub_Relocation::spec(mark), RELOC_IMM32);
-   // 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()));
- 
-   __ end_a_stub();
-   // Update current stubs pointer and restore insts_end.
- }
- // size of call stub, compiled java to interpretor
- uint size_java_to_interp() {
-   return 10;  // movl; jmp
- }
- // relocation entries for call stub, compiled java to interpretor
- uint reloc_java_to_interp() {
-   return 4;  // 3 in emit_java_to_interp + 1 in Java_Static_Call
- }
- 
- //=============================================================================
  #ifndef PRODUCT
  void MachUEPNode::format( PhaseRegAlloc *ra_, outputStream* st ) const {
    st->print_cr(  "CMP    EAX,[ECX+4]\t# Inline cache check");
    st->print_cr("\tJNE    SharedRuntime::handle_ic_miss_stub");
    st->print_cr("\tNOP");
--- 1255,1264 ----
*** 1907,1918 ****
                       opt_virtual_call_Relocation::spec(), RELOC_IMM32 );
      } else {
        emit_d32_reloc(cbuf, ($meth$$method - (int)(cbuf.insts_end()) - 4),
                       static_call_Relocation::spec(), RELOC_IMM32 );
      }
!     if (_method) {  // Emit stub for static call
!       emit_java_to_interp(cbuf);
      }
    %}
  
    enc_class Java_Dynamic_Call (method meth) %{    // JAVA DYNAMIC CALL
      MacroAssembler _masm(&cbuf);
--- 1870,1881 ----
                       opt_virtual_call_Relocation::spec(), RELOC_IMM32 );
      } else {
        emit_d32_reloc(cbuf, ($meth$$method - (int)(cbuf.insts_end()) - 4),
                       static_call_Relocation::spec(), RELOC_IMM32 );
      }
!     if (_method) {  // Emit stub for static call.
!       CompiledStaticCall::emit_to_interp_stub(cbuf);
      }
    %}
  
    enc_class Java_Dynamic_Call (method meth) %{    // JAVA DYNAMIC CALL
      MacroAssembler _masm(&cbuf);