*** old/src/cpu/x86/vm/cppInterpreter_x86.cpp	Mon Jan 12 10:51:11 2009
--- new/src/cpu/x86/vm/cppInterpreter_x86.cpp	Mon Jan 12 10:51:10 2009

*** 592,602 ****
--- 592,602 ----
    // if the compilation did not complete (either went background or bailed out).
    __ movptr(rax, (int32_t)false);
    __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::frequency_counter_overflow), rax);
  
    // for c++ interpreter can rsi really be munged?
!   __ lea(state, Address(rbp, -(int)sizeof(BytecodeInterpreter)));                               // restore state
    __ movptr(rbx, Address(state, byte_offset_of(BytecodeInterpreter, _method)));            // restore method
    __ movptr(rdi, Address(state, byte_offset_of(BytecodeInterpreter, _locals)));            // get locals pointer
  
    __ jmp(*do_continue, relocInfo::none);
  

*** 656,666 ****
--- 656,666 ----
  
    // locals + overhead, in bytes
      const Address size_of_stack    (rbx, methodOopDesc::max_stack_offset());
      // Always give one monitor to allow us to start interp if sync method.
      // Any additional monitors need a check when moving the expression stack
!     const int one_monitor = frame::interpreter_frame_monitor_size() * wordSize;
    __ load_unsigned_word(rax, size_of_stack);                            // get size of expression stack in words
    __ lea(rax, Address(noreg, rax, Interpreter::stackElementScale(), one_monitor));
    __ lea(rax, Address(rax, rdx, Interpreter::stackElementScale(), overhead_size));
  
  #ifdef ASSERT

*** 1827,1837 ****
--- 1827,1837 ----
  
    Label return_with_exception;
    Label unwind_and_forward;
  
    // restore state pointer.
!   __ lea(state, Address(rbp,  -(int)sizeof(BytecodeInterpreter)));
  
    __ movptr(rbx, STATE(_method));                       // get method
  #ifdef _LP64
    __ movptr(Address(r15_thread, Thread::pending_exception_offset()), rax);
  #else

*** 1875,1892 ****
--- 1875,1892 ----
  
    address compiled_entry = __ pc();
  
    // The FPU stack is clean if UseSSE >= 2 but must be cleaned in other cases
    if (UseSSE < 2) {
!     __ lea(state, Address(rbp,  -(int)sizeof(BytecodeInterpreter)));
      __ movptr(rbx, STATE(_result._to_call._callee));                   // get method just executed
      __ movl(rcx, Address(rbx, methodOopDesc::result_index_offset()));
      __ cmpl(rcx, AbstractInterpreter::BasicType_as_index(T_FLOAT));    // Result stub address array index
      __ jcc(Assembler::equal, do_float);
      __ cmpl(rcx, AbstractInterpreter::BasicType_as_index(T_DOUBLE));    // Result stub address array index
      __ jcc(Assembler::equal, do_double);
! #ifdef COMPILER2
! #if !defined(_LP64) || defined(COMPILER1) || !defined(COMPILER2)
      __ empty_FPU_stack();
  #endif // COMPILER2
      __ jmp(done_conv);
  
      __ bind(do_float);

*** 1926,1936 ****
--- 1926,1936 ----
    // calling convention left it (i.e. params may or may not be present)
    // Copy the result from tosca and place it on java expression stack.
  
    // Restore rsi/r13 as compiled code may not preserve it
  
!   __ lea(state, Address(rbp,  -(int)sizeof(BytecodeInterpreter)));
  
    // restore stack to what we had when we left (in case i2c extended it)
  
    __ movptr(rsp, STATE(_stack));
    __ lea(rsp, Address(rsp, wordSize));

*** 1940,1950 ****
--- 1940,1950 ----
  #ifdef _LP64
    __ cmpptr(Address(r15_thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
  #else
    __ movptr(rcx, STATE(_thread));                       // get thread
    __ cmpptr(Address(rcx, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
! #endif / __LP64
! #endif // _LP64
    __ jcc(Assembler::notZero, return_with_exception);
  
    // get method just executed
    __ movptr(rbx, STATE(_result._to_call._callee));