*** old/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Fri Jul 15 18:49:38 2011
--- new/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Fri Jul 15 18:49:38 2011

*** 542,552 ****
--- 542,552 ----
      __ retl();                      // return from leaf routine
      __ delayed()->mov(O5_savedSP, SP);
  
      // Generate regular method entry
      __ bind(slow_path);
-     __ ba(false, fast_accessor_slow_entry_path);
      __ delayed()->nop();
      return entry;
    }
    return NULL;
  }

*** 717,728 ****
--- 717,727 ----
      __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), G5_method, false);
      __ ld_ptr(STATE(_method), G5_method);
  
      Address exception_addr(G2_thread, 0, in_bytes(Thread::pending_exception_offset()));
      __ ld_ptr(exception_addr, G3_scratch);
!     __ br_notnull(G3_scratch, false, Assembler::pn, pending_exception_present);
      __ delayed()->nop();
!     __ br_notnull_short(G3_scratch, Assembler::pn, pending_exception_present);
      __ ld_ptr(Address(G5_method, 0, in_bytes(methodOopDesc::signature_handler_offset())), G3_scratch);
      __ bind(L);
    }
  
    // Push a new frame so that the args will really be stored in

*** 1290,1315 ****
--- 1289,1314 ----
  
    // deopt needs to jump to here to enter the interpreter (return a result)
    deopt_frame_manager_return_atos  = __ pc();
  
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_OBJECT), L3_scratch);    // Result stub address array index
  
  
    // deopt needs to jump to here to enter the interpreter (return a result)
    deopt_frame_manager_return_btos  = __ pc();
  
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_BOOLEAN), L3_scratch);    // Result stub address array index
  
    // deopt needs to jump to here to enter the interpreter (return a result)
    deopt_frame_manager_return_itos  = __ pc();
  
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_INT), L3_scratch);    // Result stub address array index
  
    // deopt needs to jump to here to enter the interpreter (return a result)
  
    deopt_frame_manager_return_ltos  = __ pc();

*** 1325,1349 ****
--- 1324,1348 ----
  
    __ srl (G1, 0,O1);
    __ srlx(G1,32,O0);
  #endif /* !_LP64 && COMPILER2 */
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_LONG), L3_scratch);    // Result stub address array index
  
    // deopt needs to jump to here to enter the interpreter (return a result)
  
    deopt_frame_manager_return_ftos  = __ pc();
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_FLOAT), L3_scratch);    // Result stub address array index
  
    // deopt needs to jump to here to enter the interpreter (return a result)
    deopt_frame_manager_return_dtos  = __ pc();
  
    // O0/O1 live
-   __ ba(false, return_from_deopt_common);
    __ delayed()->set(AbstractInterpreter::BasicType_as_index(T_DOUBLE), L3_scratch);    // Result stub address array index
  
    // deopt needs to jump to here to enter the interpreter (return a result)
    deopt_frame_manager_return_vtos  = __ pc();
  

*** 1396,1406 ****
--- 1395,1405 ----
    __ st_ptr(L2_scratch, STATE(_stack_limit));
  
    __ ld_ptr(STATE(_stack), L1_scratch);                // Get current stack top
    __ sub(L1_scratch, entry_size, L1_scratch);
    __ st_ptr(L1_scratch, STATE(_stack));
-   __ ba(false, entry);
    __ delayed()->add(L1_scratch, wordSize, L1_scratch);        // first real entry (undo prepush)
  
    // 2. move expression stack
  
    __ bind(loop);

*** 1649,1667 ****
--- 1648,1666 ----
  
    // new monitor slot allocated, resume the interpreter.
  
    __ set((int)BytecodeInterpreter::got_monitors, L1_scratch);
    VALIDATE_STATE(G3_scratch, 5);
-   __ ba(false, call_interpreter);
    __ delayed()->st(L1_scratch, STATE(_msg));
  
    // uncommon trap needs to jump to here to enter the interpreter (re-execute current bytecode)
    unctrap_frame_manager_entry  = __ pc();
  
    // QQQ what message do we send
  
-   __ ba(false, call_interpreter);
    __ delayed()->ld_ptr(STATE(_frame_bottom), SP);                  // restore to full stack frame
  
    //=============================================================================
    // Returning from a compiled method into a deopted method. The bytecode at the
    // bcp has completed. The result of the bytecode is in the native abi (the tosca

*** 1673,1683 ****
--- 1672,1682 ----
    generate_deopt_handling();
  
    // ready to resume the interpreter
  
    __ set((int)BytecodeInterpreter::deopt_resume, L1_scratch);
-   __ ba(false, call_interpreter);
    __ delayed()->st(L1_scratch, STATE(_msg));
  
    // Current frame has caught an exception we need to dispatch to the
    // handler. We can get here because a native interpreter frame caught
    // an exception in which case there is no handler and we must rethrow

*** 1761,1781 ****
--- 1760,1780 ----
    __ jmpl(Lscratch, G0, O7);                                                   // and convert it
    __ delayed()->nop();
  
    // L1_scratch points to top of stack (prepushed)
  
-   __ ba(false, resume_interpreter);
    __ delayed()->mov(L1_scratch, O1);
  
    // An exception is being caught on return to a vanilla interpreter frame.
    // Empty the stack and resume interpreter
  
    __ bind(return_with_exception);
  
    __ ld_ptr(STATE(_frame_bottom), SP);                             // restore to full stack frame
    __ ld_ptr(STATE(_stack_base), O1);                               // empty java expression stack
-   __ ba(false, resume_interpreter);
    __ delayed()->sub(O1, wordSize, O1);                             // account for prepush
  
    // Return from interpreted method we return result appropriate to the caller (i.e. "recursive"
    // interpreter call, or native) and unwind this interpreter activation.
    // All monitors should be unlocked.

*** 1850,1860 ****
--- 1849,1859 ----
  
    // A frame we have already used before so no need to bang stack so use call_interpreter_2 entry
  
    __ set((int)BytecodeInterpreter::method_resume, L1_scratch);
    __ st(L1_scratch, STATE(_msg));
-   __ ba(false, call_interpreter_2);
    __ delayed()->st_ptr(O1, STATE(_stack));
  
  
    // Fast accessor methods share this entry point.
    // This works because frame manager is in the same codelet

*** 1865,1875 ****
--- 1864,1874 ----
      __ bind(fast_accessor_slow_entry_path);
      __ set((intptr_t)return_from_native_method - 8, Gtmp1);
      __ cmp(Gtmp1, O7);                                                // returning to interpreter?
      __ brx(Assembler::equal, true, Assembler::pt, re_dispatch);       // yep
      __ delayed()->nop();
-     __ ba(false, re_dispatch);
      __ delayed()->mov(G0, prevState);                                 // initial entry
  
    }
  
    // interpreter returning to native code (call_stub/c1/c2)

*** 2030,2040 ****
--- 2029,2039 ----
    __ tst(L1_scratch);
    __ brx(Assembler::zero, false, Assembler::pt, unwind_and_forward);
    __ delayed()->nop();
  
    __ ld_ptr(STATE(_locals), O1); // get result of popping callee's args
-   __ ba(false, unwind_recursive_activation);
    __ delayed()->nop();
  
    interpreter_frame_manager = entry_point;
    return entry_point;
  }