src/cpu/x86/vm/frame_x86.inline.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/cpu/x86/vm

src/cpu/x86/vm/frame_x86.inline.hpp

Print this page
rev 7968 : [mq]: 6313046-deadcode


 122   return ret;
 123 }
 124 
 125 // Return unique id for this frame. The id must have a value where we can distinguish
 126 // identity and younger/older relationship. NULL represents an invalid (incomparable)
 127 // frame.
 128 inline intptr_t* frame::id(void) const { return unextended_sp(); }
 129 
 130 // Relationals on frames based
 131 // Return true if the frame is younger (more recent activation) than the frame represented by id
 132 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id");
 133                                                     return this->id() < id ; }
 134 
 135 // Return true if the frame is older (less recent activation) than the frame represented by id
 136 inline bool frame::is_older(intptr_t* id) const   { assert(this->id() != NULL && id != NULL, "NULL frame id");
 137                                                     return this->id() > id ; }
 138 
 139 
 140 
 141 inline intptr_t* frame::link() const              { return (intptr_t*) *(intptr_t **)addr_at(link_offset); }
 142 inline void      frame::set_link(intptr_t* addr)  { *(intptr_t **)addr_at(link_offset) = addr; }
 143 
 144 
 145 inline intptr_t* frame::unextended_sp() const     { return _unextended_sp; }
 146 
 147 // Return address:
 148 
 149 inline address* frame::sender_pc_addr()      const { return (address*) addr_at( return_addr_offset); }
 150 inline address  frame::sender_pc()           const { return *sender_pc_addr(); }
 151 
 152 // return address of param, zero origin index.
 153 inline address* frame::native_param_addr(int idx) const { return (address*) addr_at( native_frame_initial_param_offset+idx); }
 154 
 155 #ifdef CC_INTERP
 156 
 157 inline interpreterState frame::get_interpreterState() const {
 158   return ((interpreterState)addr_at( -((int)sizeof(BytecodeInterpreter))/wordSize ));
 159 }
 160 
 161 inline intptr_t*    frame::sender_sp()        const {
 162   // Hmm this seems awfully expensive QQQ, is this really called with interpreted frames?
 163   if (is_interpreted_frame()) {
 164     assert(false, "should never happen");
 165     return get_interpreterState()->sender_sp();
 166   } else {
 167     return            addr_at(sender_sp_offset);
 168   }
 169 }
 170 
 171 inline intptr_t** frame::interpreter_frame_locals_addr() const {
 172   assert(is_interpreted_frame(), "must be interpreted");
 173   return &(get_interpreterState()->_locals);




 122   return ret;
 123 }
 124 
 125 // Return unique id for this frame. The id must have a value where we can distinguish
 126 // identity and younger/older relationship. NULL represents an invalid (incomparable)
 127 // frame.
 128 inline intptr_t* frame::id(void) const { return unextended_sp(); }
 129 
 130 // Relationals on frames based
 131 // Return true if the frame is younger (more recent activation) than the frame represented by id
 132 inline bool frame::is_younger(intptr_t* id) const { assert(this->id() != NULL && id != NULL, "NULL frame id");
 133                                                     return this->id() < id ; }
 134 
 135 // Return true if the frame is older (less recent activation) than the frame represented by id
 136 inline bool frame::is_older(intptr_t* id) const   { assert(this->id() != NULL && id != NULL, "NULL frame id");
 137                                                     return this->id() > id ; }
 138 
 139 
 140 
 141 inline intptr_t* frame::link() const              { return (intptr_t*) *(intptr_t **)addr_at(link_offset); }


 142 
 143 inline intptr_t* frame::unextended_sp() const     { return _unextended_sp; }
 144 
 145 // Return address:
 146 
 147 inline address* frame::sender_pc_addr()      const { return (address*) addr_at( return_addr_offset); }
 148 inline address  frame::sender_pc()           const { return *sender_pc_addr(); }



 149 
 150 #ifdef CC_INTERP
 151 
 152 inline interpreterState frame::get_interpreterState() const {
 153   return ((interpreterState)addr_at( -((int)sizeof(BytecodeInterpreter))/wordSize ));
 154 }
 155 
 156 inline intptr_t*    frame::sender_sp()        const {
 157   // Hmm this seems awfully expensive QQQ, is this really called with interpreted frames?
 158   if (is_interpreted_frame()) {
 159     assert(false, "should never happen");
 160     return get_interpreterState()->sender_sp();
 161   } else {
 162     return            addr_at(sender_sp_offset);
 163   }
 164 }
 165 
 166 inline intptr_t** frame::interpreter_frame_locals_addr() const {
 167   assert(is_interpreted_frame(), "must be interpreted");
 168   return &(get_interpreterState()->_locals);


src/cpu/x86/vm/frame_x86.inline.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File