< prev index next >

src/cpu/aarch64/vm/frame_aarch64.cpp

Print this page




  96     // other generic buffer blobs are more problematic so we just assume they are
  97     // ok. adapter blobs never have a frame complete and are never ok.
  98 
  99     if (!_cb->is_frame_complete_at(_pc)) {
 100       if (_cb->is_nmethod() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
 101         return false;
 102       }
 103     }
 104 
 105     // Could just be some random pointer within the codeBlob
 106     if (!_cb->code_contains(_pc)) {
 107       return false;
 108     }
 109 
 110     // Entry frame checks
 111     if (is_entry_frame()) {
 112       // an entry frame must have a valid fp.
 113 
 114       if (!fp_safe) return false;
 115 
 116       // Validate the JavaCallWrapper an entry frame must have
 117 
 118       address jcw = (address)entry_frame_call_wrapper();
 119 
 120       bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > fp);
 121 
 122       return jcw_safe;
 123 
 124     }
 125 
 126     intptr_t* sender_sp = NULL;
 127     intptr_t* sender_unextended_sp = NULL;
 128     address   sender_pc = NULL;
 129     intptr_t* saved_fp =  NULL;
 130 
 131     if (is_interpreted_frame()) {
 132       // fp must be safe
 133       if (!fp_safe) {
 134         return false;
 135       }
 136 
 137       sender_pc = (address) this->fp()[return_addr_offset];
 138       // for interpreted frames, the value below is the sender "raw" sp,
 139       // which can be different from the sender unextended sp (the sp seen
 140       // by the sender) because of current frame local variables
 141       sender_sp = (intptr_t*) addr_at(sender_sp_offset);
 142       sender_unextended_sp = (intptr_t*) this->fp()[interpreter_frame_sender_sp_offset];
 143       saved_fp = (intptr_t*) this->fp()[link_offset];


 193 
 194     // Could just be some random pointer within the codeBlob
 195     if (!sender_blob->code_contains(sender_pc)) {
 196       return false;
 197     }
 198 
 199     // We should never be able to see an adapter if the current frame is something from code cache
 200     if (sender_blob->is_adapter_blob()) {
 201       return false;
 202     }
 203 
 204     // Could be the call_stub
 205     if (StubRoutines::returns_to_call_stub(sender_pc)) {
 206       bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
 207 
 208       if (!saved_fp_safe) {
 209         return false;
 210       }
 211 
 212       // construct the potential sender
 213 
 214       frame sender(sender_sp, sender_unextended_sp, saved_fp, sender_pc);
 215 
 216       // Validate the JavaCallWrapper an entry frame must have
 217       address jcw = (address)sender.entry_frame_call_wrapper();
 218 
 219       bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > (address)sender.fp());
 220 
 221       return jcw_safe;
 222     }
 223 
 224     CompiledMethod* nm = sender_blob->as_compiled_method_or_null();
 225     if (nm != NULL) {
 226       if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc) ||
 227           nm->method()->is_method_handle_intrinsic()) {
 228         return false;
 229       }
 230     }
 231 
 232     // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
 233     // because the return address counts against the callee's frame.
 234 
 235     if (sender_blob->frame_size() <= 0) {
 236       assert(!sender_blob->is_compiled(), "should count return address at least");
 237       return false;
 238     }
 239 
 240     // We should never be able to see anything here except an nmethod. If something in the
 241     // code cache (current frame) is called by an entity within the code cache that entity




  96     // other generic buffer blobs are more problematic so we just assume they are
  97     // ok. adapter blobs never have a frame complete and are never ok.
  98 
  99     if (!_cb->is_frame_complete_at(_pc)) {
 100       if (_cb->is_nmethod() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
 101         return false;
 102       }
 103     }
 104 
 105     // Could just be some random pointer within the codeBlob
 106     if (!_cb->code_contains(_pc)) {
 107       return false;
 108     }
 109 
 110     // Entry frame checks
 111     if (is_entry_frame()) {
 112       // an entry frame must have a valid fp.
 113 
 114       if (!fp_safe) return false;
 115  
 116       return entry_frame_is_safe(thread);







 117     }
 118 
 119     intptr_t* sender_sp = NULL;
 120     intptr_t* sender_unextended_sp = NULL;
 121     address   sender_pc = NULL;
 122     intptr_t* saved_fp =  NULL;
 123 
 124     if (is_interpreted_frame()) {
 125       // fp must be safe
 126       if (!fp_safe) {
 127         return false;
 128       }
 129 
 130       sender_pc = (address) this->fp()[return_addr_offset];
 131       // for interpreted frames, the value below is the sender "raw" sp,
 132       // which can be different from the sender unextended sp (the sp seen
 133       // by the sender) because of current frame local variables
 134       sender_sp = (intptr_t*) addr_at(sender_sp_offset);
 135       sender_unextended_sp = (intptr_t*) this->fp()[interpreter_frame_sender_sp_offset];
 136       saved_fp = (intptr_t*) this->fp()[link_offset];


 186 
 187     // Could just be some random pointer within the codeBlob
 188     if (!sender_blob->code_contains(sender_pc)) {
 189       return false;
 190     }
 191 
 192     // We should never be able to see an adapter if the current frame is something from code cache
 193     if (sender_blob->is_adapter_blob()) {
 194       return false;
 195     }
 196 
 197     // Could be the call_stub
 198     if (StubRoutines::returns_to_call_stub(sender_pc)) {
 199       bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
 200 
 201       if (!saved_fp_safe) {
 202         return false;
 203       }
 204 
 205       // construct the potential sender

 206       frame sender(sender_sp, sender_unextended_sp, saved_fp, sender_pc);
 207       return sender.is_entry_frame_safe(thread);






 208     }
 209 
 210     CompiledMethod* nm = sender_blob->as_compiled_method_or_null();
 211     if (nm != NULL) {
 212       if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc) ||
 213           nm->method()->is_method_handle_intrinsic()) {
 214         return false;
 215       }
 216     }
 217 
 218     // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
 219     // because the return address counts against the callee's frame.
 220 
 221     if (sender_blob->frame_size() <= 0) {
 222       assert(!sender_blob->is_compiled(), "should count return address at least");
 223       return false;
 224     }
 225 
 226     // We should never be able to see anything here except an nmethod. If something in the
 227     // code cache (current frame) is called by an entity within the code cache that entity


< prev index next >