1 /*
   2  * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef CPU_SPARC_FRAME_SPARC_INLINE_HPP
  26 #define CPU_SPARC_FRAME_SPARC_INLINE_HPP
  27 
  28 #include "asm/macroAssembler.hpp"
  29 #include "code/vmreg.inline.hpp"
  30 #include "utilities/align.hpp"
  31 
  32 // Inline functions for SPARC frames:
  33 
  34 // Constructors
  35 
  36 inline frame::frame() {
  37   _pc = NULL;
  38   _sp = NULL;
  39   _younger_sp = NULL;
  40   _cb = NULL;
  41   _deopt_state = unknown;
  42   _sp_adjustment_by_callee = 0;
  43 }
  44 
  45 // Accessors:
  46 
  47 inline bool frame::equal(frame other) const {
  48   bool ret =  sp() == other.sp()
  49            && fp() == other.fp()
  50            && pc() == other.pc();
  51   assert(!ret || ret && cb() == other.cb() && _deopt_state == other._deopt_state, "inconsistent construction");
  52   return ret;
  53 }
  54 
  55 // Return unique id for this frame. The id must have a value where we can distinguish
  56 // identity and younger/older relationship. NULL represents an invalid (incomparable)
  57 // frame.
  58 inline intptr_t* frame::id(void) const { return unextended_sp(); }
  59 
  60 // Return true if the frame is older (less recent activation) than the frame represented by id
  61 inline bool frame::is_older(intptr_t* id) const   { assert(this->id() != NULL && id != NULL, "NULL frame id");
  62                                                     return this->id() > id ; }
  63 
  64 inline int frame::frame_size(RegisterMap* map) const { return sender_sp() - sp(); }
  65 
  66 inline intptr_t* frame::link() const { return (intptr_t *)(fp()[FP->sp_offset_in_saved_window()] + STACK_BIAS); }
  67 
  68 inline intptr_t* frame::unextended_sp() const { return sp() + _sp_adjustment_by_callee; }
  69 
  70 // return address:
  71 
  72 inline address  frame::sender_pc()        const    { return *I7_addr() + pc_return_offset; }
  73 
  74 inline address* frame::I7_addr() const  { return (address*) &sp()[ I7->sp_offset_in_saved_window()]; }
  75 inline address* frame::I0_addr() const  { return (address*) &sp()[ I0->sp_offset_in_saved_window()]; }
  76 
  77 inline address* frame::O7_addr() const  { return (address*) &younger_sp()[ I7->sp_offset_in_saved_window()]; }
  78 inline address* frame::O0_addr() const  { return (address*) &younger_sp()[ I0->sp_offset_in_saved_window()]; }
  79 
  80 inline intptr_t*    frame::sender_sp() const  { return fp(); }
  81 
  82 inline intptr_t* frame::real_fp() const { return fp(); }
  83 
  84 inline intptr_t** frame::interpreter_frame_locals_addr() const {
  85   return (intptr_t**) sp_addr_at( Llocals->sp_offset_in_saved_window());
  86 }
  87 
  88 inline intptr_t* frame::interpreter_frame_bcp_addr() const {
  89   return (intptr_t*) sp_addr_at( Lbcp->sp_offset_in_saved_window());
  90 }
  91 
  92 inline intptr_t* frame::interpreter_frame_mdp_addr() const {
  93   // %%%%% reinterpreting ImethodDataPtr as a mdx
  94   return (intptr_t*) sp_addr_at( ImethodDataPtr->sp_offset_in_saved_window());
  95 }
  96 
  97 // bottom(base) of the expression stack (highest address)
  98 inline intptr_t* frame::interpreter_frame_expression_stack() const {
  99   return (intptr_t*)interpreter_frame_monitors() - 1;
 100 }
 101 
 102 // top of expression stack (lowest address)
 103 inline intptr_t* frame::interpreter_frame_tos_address() const {
 104   return *interpreter_frame_esp_addr() + 1;
 105 }
 106 
 107 inline BasicObjectLock** frame::interpreter_frame_monitors_addr() const {
 108   return (BasicObjectLock**) sp_addr_at(Lmonitors->sp_offset_in_saved_window());
 109 }
 110 inline intptr_t** frame::interpreter_frame_esp_addr() const {
 111   return (intptr_t**)sp_addr_at(Lesp->sp_offset_in_saved_window());
 112 }
 113 
 114 inline void frame::interpreter_frame_set_tos_address( intptr_t* x ) {
 115   *interpreter_frame_esp_addr() = x - 1;
 116 }
 117 
 118 // monitor elements
 119 
 120 // in keeping with Intel side: end is lower in memory than begin;
 121 // and beginning element is oldest element
 122 // Also begin is one past last monitor.
 123 
 124 inline BasicObjectLock* frame::interpreter_frame_monitor_begin()       const  {
 125   int rounded_vm_local_words = align_up((int)frame::interpreter_frame_vm_local_words, WordsPerLong);
 126   return (BasicObjectLock *)fp_addr_at(-rounded_vm_local_words);
 127 }
 128 
 129 inline BasicObjectLock* frame::interpreter_frame_monitor_end()         const  {
 130   return interpreter_frame_monitors();
 131 }
 132 
 133 
 134 inline void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
 135   interpreter_frame_set_monitors(value);
 136 }
 137 
 138 inline int frame::interpreter_frame_monitor_size() {
 139   return align_up(BasicObjectLock::size(), WordsPerLong);
 140 }
 141 
 142 inline Method** frame::interpreter_frame_method_addr() const {
 143   return (Method**)sp_addr_at( Lmethod->sp_offset_in_saved_window());
 144 }
 145 
 146 inline BasicObjectLock* frame::interpreter_frame_monitors() const {
 147   return *interpreter_frame_monitors_addr();
 148 }
 149 
 150 inline void frame::interpreter_frame_set_monitors(BasicObjectLock* monitors) {
 151   *interpreter_frame_monitors_addr() = monitors;
 152 }
 153 
 154 inline oop* frame::interpreter_frame_mirror_addr() const {
 155   return (oop*)(fp() + interpreter_frame_mirror_offset);
 156 }
 157 
 158 // Constant pool cache
 159 
 160 // where LcpoolCache is saved:
 161 inline ConstantPoolCache** frame::interpreter_frame_cpoolcache_addr() const {
 162     return (ConstantPoolCache**)sp_addr_at(LcpoolCache->sp_offset_in_saved_window());
 163   }
 164 
 165 inline ConstantPoolCache** frame::interpreter_frame_cache_addr() const {
 166   return (ConstantPoolCache**)sp_addr_at( LcpoolCache->sp_offset_in_saved_window());
 167 }
 168 
 169 inline oop* frame::interpreter_frame_temp_oop_addr() const {
 170   return (oop *)(fp() + interpreter_frame_oop_temp_offset);
 171 }
 172 
 173 
 174 inline JavaCallWrapper** frame::entry_frame_call_wrapper_addr() const {
 175   // note: adjust this code if the link argument in StubGenerator::call_stub() changes!
 176   const Argument link = Argument(0, false);
 177   return (JavaCallWrapper**)&sp()[link.as_in().as_register()->sp_offset_in_saved_window()];
 178 }
 179 
 180 
 181 inline oop  frame::saved_oop_result(RegisterMap* map) const      {
 182   return *((oop*) map->location(O0->as_VMReg()));
 183 }
 184 
 185 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) {
 186   *((oop*) map->location(O0->as_VMReg())) = obj;
 187 }
 188 
 189 #endif // CPU_SPARC_FRAME_SPARC_INLINE_HPP