*** old/src/cpu/aarch64/vm/frame_aarch64.cpp	Thu Dec 17 17:51:53 2015
--- new/src/cpu/aarch64/vm/frame_aarch64.cpp	Thu Dec 17 17:51:52 2015

*** 311,341 ****
--- 311,320 ----
    // Entry frame's arguments are always in relation to unextended_sp()
    return &unextended_sp()[index];
  }
  
  // sender_sp
  #ifdef CC_INTERP
  intptr_t* frame::interpreter_frame_sender_sp() const {
    assert(is_interpreted_frame(), "interpreted frame expected");
    // QQQ why does this specialize method exist if frame::sender_sp() does same thing?
    // seems odd and if we always know interpreted vs. non then sender_sp() is really
    // doing too much work.
    return get_interpreterState()->sender_sp();
  }
  
  // monitor elements
  
  BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
    return get_interpreterState()->monitor_base();
  }
  
  BasicObjectLock* frame::interpreter_frame_monitor_end() const {
    return (BasicObjectLock*) get_interpreterState()->stack_base();
  }
  
  #else // CC_INTERP
  
  intptr_t* frame::interpreter_frame_sender_sp() const {
    assert(is_interpreted_frame(), "interpreted frame expected");
    return (intptr_t*) at(interpreter_frame_sender_sp_offset);
  }
  

*** 365,375 ****
--- 344,353 ----
  
  // Used by template based interpreter deoptimization
  void frame::interpreter_frame_set_last_sp(intptr_t* sp) {
      *((intptr_t**)addr_at(interpreter_frame_last_sp_offset)) = sp;
  }
  #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

*** 525,537 ****
--- 503,512 ----
    // methods that exists in the core system.
    return frame(sender_sp(), link(), sender_pc());
  }
  
  bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
  // QQQ
  #ifdef CC_INTERP
  #else
    assert(is_interpreted_frame(), "Not an interpreted frame");
    // These are reasonable sanity checks
    if (fp() == 0 || (intptr_t(fp()) & (wordSize-1)) != 0) {
      return false;
    }

*** 581,601 ****
--- 556,569 ----
    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;
  }
  
  BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
  #ifdef CC_INTERP
    // Needed for JVMTI. The result should always be in the
    // interpreterState object
    interpreterState istate = get_interpreterState();
  #endif // CC_INTERP
    assert(is_interpreted_frame(), "interpreted frame expected");
    Method* method = interpreter_frame_method();
    BasicType type = method->result_type();
  
    intptr_t* tos_addr;

*** 617,631 ****
--- 585,595 ----
    switch (type) {
      case T_OBJECT  :
      case T_ARRAY   : {
        oop obj;
        if (method->is_native()) {
  #ifdef CC_INTERP
          obj = istate->_oop_temp;
  #else
          obj = cast_to_oop(at(interpreter_frame_oop_temp_offset));
  #endif // CC_INTERP
        } else {
          oop* obj_p = (oop*)tos_addr;
          obj = (obj_p == NULL) ? (oop)NULL : *obj_p;
        }
        assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");