*** old/src/cpu/sparc/vm/frame_sparc.cpp	Thu Dec 17 17:51:58 2015
--- new/src/cpu/sparc/vm/frame_sparc.cpp	Thu Dec 17 17:51:58 2015

*** 439,454 ****
--- 439,452 ----
  intptr_t* frame::interpreter_frame_sender_sp() const {
    assert(is_interpreted_frame(), "interpreted frame expected");
    return fp();
  }
  
  #ifndef CC_INTERP
  void frame::set_interpreter_frame_sender_sp(intptr_t* sender_sp) {
    assert(is_interpreted_frame(), "interpreted frame expected");
    Unimplemented();
  }
  #endif // CC_INTERP
  
  frame frame::sender_for_entry_frame(RegisterMap *map) const {
    assert(map != NULL, "map must be set");
    // Java frame called from C; skip all C frames and return top C
    // frame of that chunk as the sender

*** 598,610 ****
--- 596,605 ----
  bool frame::is_valid_stack_pointer(intptr_t* valid_sp, intptr_t* sp) {
    return next_younger_sp_or_null(valid_sp, sp) != NULL;
  }
  
  bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
  #ifdef CC_INTERP
    // Is there anything to do?
  #else
    assert(is_interpreted_frame(), "Not an interpreted frame");
    // These are reasonable sanity checks
    if (fp() == 0 || (intptr_t(fp()) & (2*wordSize-1)) != 0) {
      return false;
    }

*** 652,662 ****
--- 647,656 ----
    address locals =  (address) *interpreter_frame_locals_addr();
  
    if (locals > thread->stack_base() || locals < (address) fp()) return false;
  
    // We'd have to be pretty unlucky to be mislead at this point
  #endif /* CC_INTERP */
    return true;
  }
  
  
  // Windows have been flushed on entry (but not marked). Capture the pc that

*** 710,727 ****
--- 704,715 ----
  
    if (method->is_native()) {
      // Prior to notifying the runtime of the method_exit the possible result
      // value is saved to l_scratch and d_scratch.
  
  #ifdef CC_INTERP
      interpreterState istate = get_interpreterState();
      intptr_t* l_scratch = (intptr_t*) &istate->_native_lresult;
      intptr_t* d_scratch = (intptr_t*) &istate->_native_fresult;
  #else /* CC_INTERP */
      intptr_t* l_scratch = fp() + interpreter_frame_l_scratch_fp_offset;
      intptr_t* d_scratch = fp() + interpreter_frame_d_scratch_fp_offset;
  #endif /* CC_INTERP */
  
      address l_addr = (address)l_scratch;
  #ifdef _LP64
      // On 64-bit the result for 1/8/16/32-bit result types is in the other
      // word half

*** 729,745 ****
--- 717,729 ----
  #endif
  
      switch (type) {
        case T_OBJECT:
        case T_ARRAY: {
  #ifdef CC_INTERP
          *oop_result = istate->_oop_temp;
  #else
          oop obj = cast_to_oop(at(interpreter_frame_oop_temp_offset));
          assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
          *oop_result = obj;
  #endif // CC_INTERP
          break;
        }
  
        case T_BOOLEAN : { jint* p = (jint*)l_addr; value_result->z = (jboolean)((*p) & 0x1); break; }
        case T_BYTE    : { jint* p = (jint*)l_addr; value_result->b = (jbyte)((*p) & 0xff); break; }

*** 795,816 ****
--- 779,798 ----
    for (int w = 0; w < frame::register_save_words; w++) {
      values.describe(frame_no, sp() + w, err_msg("register save area word %d", w), 1);
    }
  
    if (is_interpreted_frame()) {
  #ifndef CC_INTERP
      DESCRIBE_FP_OFFSET(interpreter_frame_d_scratch_fp);
      DESCRIBE_FP_OFFSET(interpreter_frame_l_scratch_fp);
      DESCRIBE_FP_OFFSET(interpreter_frame_padding);
      DESCRIBE_FP_OFFSET(interpreter_frame_oop_temp);
  
      // esp, according to Lesp (e.g. not depending on bci), if seems valid
      intptr_t* esp = *interpreter_frame_esp_addr();
      if ((esp >= sp()) && (esp < fp())) {
        values.describe(-1, esp, "*Lesp");
      }
  #endif
    }
  
    if (!is_compiled_frame()) {
      if (frame::callee_aggregate_return_pointer_words != 0) {
        values.describe(frame_no, sp() + frame::callee_aggregate_return_pointer_sp_offset, "callee_aggregate_return_pointer_word");