1 /*
   2  * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  20  * CA 95054 USA or visit www.sun.com if you need additional information or
  21  * have any questions.
  22  *
  23  */
  24 
  25 // Inline functions for Intel frames:
  26 
  27 // Constructors:
  28 
  29 inline frame::frame() {
  30   _pc = NULL;
  31   _sp = NULL;
  32   _unextended_sp = NULL;
  33   _fp = NULL;
  34   _cb = NULL;
  35   _deopt_state = unknown;
  36 }
  37 
  38 inline frame:: frame(intptr_t* sp, intptr_t* fp, address pc) {
  39   _sp = sp;
  40   _unextended_sp = sp;
  41   _fp = fp;
  42   _pc = pc;
  43   assert(pc != NULL, "no pc?");
  44   _cb = CodeCache::find_blob(pc);
  45   _deopt_state = not_deoptimized;
  46   if (_cb != NULL && _cb->is_nmethod() && ((nmethod*)_cb)->is_deopt_pc(_pc)) {
  47     _pc = (((nmethod*)_cb)->get_original_pc(this));
  48     _deopt_state = is_deoptimized;
  49   } else {
  50     _deopt_state = not_deoptimized;
  51   }
  52 }
  53 
  54 inline frame:: frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc) {
  55   _sp = sp;
  56   _unextended_sp = unextended_sp;
  57   _fp = fp;
  58   _pc = pc;
  59   assert(pc != NULL, "no pc?");
  60   _cb = CodeCache::find_blob(pc);
  61   _deopt_state = not_deoptimized;
  62   if (_cb != NULL && _cb->is_nmethod() && ((nmethod*)_cb)->is_deopt_pc(_pc)) {
  63     _pc = (((nmethod*)_cb)->get_original_pc(this));
  64     _deopt_state = is_deoptimized;
  65   } else {
  66     _deopt_state = not_deoptimized;
  67   }
  68 }
  69 
  70 inline frame::frame(intptr_t* sp, intptr_t* fp) {
  71   _sp = sp;
  72   _unextended_sp = sp;
  73   _fp = fp;
  74   _pc = (address)(sp[-1]);
  75 
  76   // Here's a sticky one. This constructor can be called via AsyncGetCallTrace
  77   // when last_Java_sp is non-null but the pc fetched is junk. If we are truly
  78   // unlucky the junk value could be to a zombied method and we'll die on the
  79   // find_blob call. This is also why we can have no asserts on the validity
  80   // of the pc we find here. AsyncGetCallTrace -> pd_get_top_frame_for_signal_handler
  81   // -> pd_last_frame should use a specialized version of pd_last_frame which could
  82   // call a specilaized frame constructor instead of this one.
  83   // Then we could use the assert below. However this assert is of somewhat dubious
  84   // value.
  85   // assert(_pc != NULL, "no pc?");
  86 
  87   _cb = CodeCache::find_blob(_pc);
  88 
  89   _deopt_state = not_deoptimized;
  90   if (_cb != NULL && _cb->is_nmethod() && ((nmethod*)_cb)->is_deopt_pc(_pc)) {
  91     _pc = (((nmethod*)_cb)->get_original_pc(this));
  92     _deopt_state = is_deoptimized;
  93   } else {
  94     _deopt_state = not_deoptimized;
  95   }
  96 }
  97 
  98 // Accessors
  99 
 100 inline bool frame::equal(frame other) const {
 101   bool ret =  sp() == other.sp()
 102               && unextended_sp() == other.unextended_sp()
 103               && fp() == other.fp()
 104               && pc() == other.pc();
 105   assert(!ret || ret && cb() == other.cb() && _deopt_state == other._deopt_state, "inconsistent construction");
 106   return ret;
 107 }
 108 
 109 // Return unique id for this frame. The id must have a value where we can distinguish
 110 // identity and younger/older relationship. NULL represents an invalid (incomparable)
 111 // frame.
 112 inline intptr_t* frame::id(void) const { return unextended_sp(); }
 113 
 114 // Relationals on frames based
 115 // Return true if the frame is younger (more recent activation) than the frame represented by id
 116 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id");
 117                                                     return this->id() < id ; }
 118 
 119 // Return true if the frame is older (less recent activation) than the frame represented by id
 120 inline bool frame::is_older(intptr_t* id) const   { assert(this->id() != NULL && id != NULL, "NULL frame id");
 121                                                     return this->id() > id ; }
 122 
 123 
 124 
 125 inline intptr_t* frame::link() const              { return (intptr_t*) *(intptr_t **)addr_at(link_offset); }
 126 inline void      frame::set_link(intptr_t* addr)  { *(intptr_t **)addr_at(link_offset) = addr; }
 127 
 128 
 129 inline intptr_t* frame::unextended_sp() const     { return _unextended_sp; }
 130 
 131 // Return address:
 132 
 133 inline address* frame::sender_pc_addr()      const { return (address*) addr_at( return_addr_offset); }
 134 inline address  frame::sender_pc()           const { return *sender_pc_addr(); }
 135 
 136 // return address of param, zero origin index.
 137 inline address* frame::native_param_addr(int idx) const { return (address*) addr_at( native_frame_initial_param_offset+idx); }
 138 
 139 #ifdef CC_INTERP
 140 
 141 inline interpreterState frame::get_interpreterState() const {
 142   return ((interpreterState)addr_at( -((int)sizeof(BytecodeInterpreter))/wordSize ));
 143 }
 144 
 145 inline intptr_t*    frame::sender_sp()        const {
 146   // Hmm this seems awfully expensive QQQ, is this really called with interpreted frames?
 147   if (is_interpreted_frame()) {
 148     assert(false, "should never happen");
 149     return get_interpreterState()->sender_sp();
 150   } else {
 151     return            addr_at(sender_sp_offset);
 152   }
 153 }
 154 
 155 inline intptr_t** frame::interpreter_frame_locals_addr() const {
 156   assert(is_interpreted_frame(), "must be interpreted");
 157   return &(get_interpreterState()->_locals);
 158 }
 159 
 160 inline intptr_t* frame::interpreter_frame_bcx_addr() const {
 161   assert(is_interpreted_frame(), "must be interpreted");
 162   return (intptr_t*) &(get_interpreterState()->_bcp);
 163 }
 164 
 165 
 166 // Constant pool cache
 167 
 168 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const {
 169   assert(is_interpreted_frame(), "must be interpreted");
 170   return &(get_interpreterState()->_constants);
 171 }
 172 
 173 // Method
 174 
 175 inline methodOop* frame::interpreter_frame_method_addr() const {
 176   assert(is_interpreted_frame(), "must be interpreted");
 177   return &(get_interpreterState()->_method);
 178 }
 179 
 180 inline intptr_t* frame::interpreter_frame_mdx_addr() const {
 181   assert(is_interpreted_frame(), "must be interpreted");
 182   return (intptr_t*) &(get_interpreterState()->_mdx);
 183 }
 184 
 185 // top of expression stack
 186 inline intptr_t* frame::interpreter_frame_tos_address() const {
 187   assert(is_interpreted_frame(), "wrong frame type");
 188   return get_interpreterState()->_stack + 1;
 189 }
 190 
 191 #else /* asm interpreter */
 192 inline intptr_t*    frame::sender_sp()        const { return            addr_at(   sender_sp_offset); }
 193 
 194 inline intptr_t** frame::interpreter_frame_locals_addr() const {
 195   return (intptr_t**)addr_at(interpreter_frame_locals_offset);
 196 }
 197 
 198 inline intptr_t* frame::interpreter_frame_last_sp() const {
 199   return *(intptr_t**)addr_at(interpreter_frame_last_sp_offset);
 200 }
 201 
 202 inline intptr_t* frame::interpreter_frame_bcx_addr() const {
 203   return (intptr_t*)addr_at(interpreter_frame_bcx_offset);
 204 }
 205 
 206 
 207 inline intptr_t* frame::interpreter_frame_mdx_addr() const {
 208   return (intptr_t*)addr_at(interpreter_frame_mdx_offset);
 209 }
 210 
 211 
 212 
 213 // Constant pool cache
 214 
 215 inline constantPoolCacheOop* frame::interpreter_frame_cache_addr() const {
 216   return (constantPoolCacheOop*)addr_at(interpreter_frame_cache_offset);
 217 }
 218 
 219 // Method
 220 
 221 inline methodOop* frame::interpreter_frame_method_addr() const {
 222   return (methodOop*)addr_at(interpreter_frame_method_offset);
 223 }
 224 
 225 // top of expression stack
 226 inline intptr_t* frame::interpreter_frame_tos_address() const {
 227   intptr_t* last_sp = interpreter_frame_last_sp();
 228   if (last_sp == NULL ) {
 229     return sp();
 230   } else {
 231     // sp() may have been extended by an adapter
 232     assert(last_sp < fp() && last_sp >= sp(), "bad tos");
 233     return last_sp;
 234   }
 235 }
 236 
 237 #endif /* CC_INTERP */
 238 
 239 inline int frame::pd_oop_map_offset_adjustment() const {
 240   return 0;
 241 }
 242 
 243 inline int frame::interpreter_frame_monitor_size() {
 244   return BasicObjectLock::size();
 245 }
 246 
 247 
 248 // expression stack
 249 // (the max_stack arguments are used by the GC; see class FrameClosure)
 250 
 251 inline intptr_t* frame::interpreter_frame_expression_stack() const {
 252   intptr_t* monitor_end = (intptr_t*) interpreter_frame_monitor_end();
 253   return monitor_end-1;
 254 }
 255 
 256 
 257 inline jint frame::interpreter_frame_expression_stack_direction() { return -1; }
 258 
 259 
 260 // Entry frames
 261 
 262 inline JavaCallWrapper* frame::entry_frame_call_wrapper() const {
 263  return (JavaCallWrapper*)at(entry_frame_call_wrapper_offset);
 264 }
 265 
 266 
 267 // Compiled frames
 268 
 269 inline int frame::local_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) {
 270   return (nof_args - local_index + (local_index < nof_args ? 1: -1));
 271 }
 272 
 273 inline int frame::monitor_offset_for_compiler(int local_index, int nof_args, int max_nof_locals, int max_nof_monitors) {
 274   return local_offset_for_compiler(local_index, nof_args, max_nof_locals, max_nof_monitors);
 275 }
 276 
 277 inline int frame::min_local_offset_for_compiler(int nof_args, int max_nof_locals, int max_nof_monitors) {
 278   return (nof_args - (max_nof_locals + max_nof_monitors*2) - 1);
 279 }
 280 
 281 inline bool frame::volatile_across_calls(Register reg) {
 282   return true;
 283 }
 284 
 285 
 286 
 287 inline oop frame::saved_oop_result(RegisterMap* map) const       {
 288   return *((oop*) map->location(rax->as_VMReg()));
 289 }
 290 
 291 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) {
 292   *((oop*) map->location(rax->as_VMReg())) = obj;
 293 }