*** old/src/hotspot/cpu/arm/frame_arm.cpp	Mon Sep 17 10:29:53 2018
--- new/src/hotspot/cpu/arm/frame_arm.cpp	Mon Sep 17 10:29:52 2018

*** 302,353 ****
--- 302,333 ----
  
  void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
    *((BasicObjectLock**)addr_at(interpreter_frame_monitor_block_top_offset)) = value;
  }
  
  #ifdef AARCH64
  
  // Used by template based interpreter deoptimization
  void frame::interpreter_frame_set_stack_top(intptr_t* stack_top) {
    *((intptr_t**)addr_at(interpreter_frame_stack_top_offset)) = stack_top;
  }
  
  // Used by template based interpreter deoptimization
  void frame::interpreter_frame_set_extended_sp(intptr_t* sp) {
    *((intptr_t**)addr_at(interpreter_frame_extended_sp_offset)) = sp;
  }
  
  #else
  
  // 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 // AARCH64
  
  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
    JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();
    assert(!entry_frame_is_first(), "next Java fp must be non zero");
    assert(jfa->last_Java_sp() > sp(), "must be above this frame on stack");
    map->clear();
    assert(map->include_argument_oops(), "should be set by clear");
  #ifdef AARCH64
    assert (jfa->last_Java_pc() != NULL, "pc should be stored");
    frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc());
    return fr;
  #else
    if (jfa->last_Java_pc() != NULL) {
      frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc());
      return fr;
    }
    frame fr(jfa->last_Java_sp(), jfa->last_Java_fp());
    return fr;
  #endif // AARCH64
  }
  
  //------------------------------------------------------------------------------
  // frame::verify_deopt_original_pc
  //

*** 401,414 ****
--- 381,390 ----
  //------------------------------------------------------------------------------
  // frame::update_map_with_saved_link
  void frame::update_map_with_saved_link(RegisterMap* map, intptr_t** link_addr) {
    // see x86 for comments
    map->set_location(FP->as_VMReg(), (address) link_addr);
  #ifdef AARCH64
    // also adjust a high part of register
    map->set_location(FP->as_VMReg()->next(), (address) link_addr);
  #endif // AARCH64
  }
  
  frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
    // SP is the raw SP from the sender after adapter or interpreter
    // extension.

*** 537,563 ****
--- 513,530 ----
  
    intptr_t* res_addr;
    if (method->is_native()) {
      // Prior to calling into the runtime to report the method_exit both of
      // the possible return value registers are saved.
  #ifdef AARCH64
      // Return value registers are saved into the frame
      if (type == T_FLOAT || type == T_DOUBLE) {
        res_addr = addr_at(interpreter_frame_fp_saved_result_offset);
      } else {
        res_addr = addr_at(interpreter_frame_gp_saved_result_offset);
      }
  #else
      // Return value registers are pushed to the native stack
      res_addr = (intptr_t*)sp();
  #ifdef __ABI_HARD__
      // FP result is pushed onto a stack along with integer result registers
      if (type == T_FLOAT || type == T_DOUBLE) {
        res_addr += 2;
      }
  #endif // __ABI_HARD__
  #endif // AARCH64
    } else {
      res_addr = (intptr_t*)interpreter_frame_tos_address();
    }
  
    switch (type) {

*** 600,615 ****
--- 567,577 ----
    values.describe(frame_no, fp() + frame::name##_offset, #name)
  
  void frame::describe_pd(FrameValues& values, int frame_no) {
    if (is_interpreted_frame()) {
      DESCRIBE_FP_OFFSET(interpreter_frame_sender_sp);
  #ifdef AARCH64
      DESCRIBE_FP_OFFSET(interpreter_frame_stack_top);
      DESCRIBE_FP_OFFSET(interpreter_frame_extended_sp);
  #else
      DESCRIBE_FP_OFFSET(interpreter_frame_last_sp);
  #endif // AARCH64
      DESCRIBE_FP_OFFSET(interpreter_frame_method);
      DESCRIBE_FP_OFFSET(interpreter_frame_mdp);
      DESCRIBE_FP_OFFSET(interpreter_frame_cache);
      DESCRIBE_FP_OFFSET(interpreter_frame_locals);
      DESCRIBE_FP_OFFSET(interpreter_frame_bcp);

*** 629,639 ****
--- 591,600 ----
    // used to reset the saved FP
    return fp();
  }
  
  intptr_t* frame::real_fp() const {
  #ifndef AARCH64
    if (is_entry_frame()) {
      // Work-around: FP (currently) does not conform to the ABI for entry
      // frames (see generate_call_stub). Might be worth fixing as another CR.
      // Following code assumes (and asserts) this has not yet been fixed.
      assert(frame::entry_frame_call_wrapper_offset == 0, "adjust this code");

*** 642,652 ****
--- 603,612 ----
  #ifndef __SOFTFP__
      new_fp += 8*2; // saved D8..D15
  #endif
      return new_fp;
    }
  #endif // !AARCH64
    if (_cb != NULL) {
      // use the frame size if valid
      int size = _cb->frame_size();
      if (size > 0) {
        return unextended_sp() + size;