94 // other generic buffer blobs are more problematic so we just assume they are
95 // ok. adapter blobs never have a frame complete and are never ok.
96
97 if (!_cb->is_frame_complete_at(_pc)) {
98 if (_cb->is_compiled() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
99 return false;
100 }
101 }
102
103 // Could just be some random pointer within the codeBlob
104 if (!_cb->code_contains(_pc)) {
105 return false;
106 }
107
108 // Entry frame checks
109 if (is_entry_frame()) {
110 // an entry frame must have a valid fp.
111
112 if (!fp_safe) return false;
113
114 // Validate the JavaCallWrapper an entry frame must have
115
116 address jcw = (address)entry_frame_call_wrapper();
117
118 bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > fp);
119
120 return jcw_safe;
121
122 }
123
124 intptr_t* sender_sp = NULL;
125 intptr_t* sender_unextended_sp = NULL;
126 address sender_pc = NULL;
127 intptr_t* saved_fp = NULL;
128
129 if (is_interpreted_frame()) {
130 // fp must be safe
131 if (!fp_safe) {
132 return false;
133 }
134
135 sender_pc = (address) this->fp()[return_addr_offset];
136 // for interpreted frames, the value below is the sender "raw" sp,
137 // which can be different from the sender unextended sp (the sp seen
138 // by the sender) because of current frame local variables
139 sender_sp = (intptr_t*) addr_at(sender_sp_offset);
140 sender_unextended_sp = (intptr_t*) this->fp()[interpreter_frame_sender_sp_offset];
141 saved_fp = (intptr_t*) this->fp()[link_offset];
192
193 // Could just be some random pointer within the codeBlob
194 if (!sender_blob->code_contains(sender_pc)) {
195 return false;
196 }
197
198 // We should never be able to see an adapter if the current frame is something from code cache
199 if (sender_blob->is_adapter_blob()) {
200 return false;
201 }
202
203 // Could be the call_stub
204 if (StubRoutines::returns_to_call_stub(sender_pc)) {
205 bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
206
207 if (!saved_fp_safe) {
208 return false;
209 }
210
211 // construct the potential sender
212
213 frame sender(sender_sp, sender_unextended_sp, saved_fp, sender_pc);
214
215 // Validate the JavaCallWrapper an entry frame must have
216 address jcw = (address)sender.entry_frame_call_wrapper();
217
218 bool jcw_safe = (jcw < thread->stack_base()) && ( jcw > (address)sender.fp());
219
220 return jcw_safe;
221 }
222
223 CompiledMethod* nm = sender_blob->as_compiled_method_or_null();
224 if (nm != NULL) {
225 if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc) ||
226 nm->method()->is_method_handle_intrinsic()) {
227 return false;
228 }
229 }
230
231 // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
232 // because the return address counts against the callee's frame.
233
234 if (sender_blob->frame_size() <= 0) {
235 assert(!sender_blob->is_compiled(), "should count return address at least");
236 return false;
237 }
238
239 // We should never be able to see anything here except an nmethod. If something in the
240 // code cache (current frame) is called by an entity within the code cache that entity
|
94 // other generic buffer blobs are more problematic so we just assume they are
95 // ok. adapter blobs never have a frame complete and are never ok.
96
97 if (!_cb->is_frame_complete_at(_pc)) {
98 if (_cb->is_compiled() || _cb->is_adapter_blob() || _cb->is_runtime_stub()) {
99 return false;
100 }
101 }
102
103 // Could just be some random pointer within the codeBlob
104 if (!_cb->code_contains(_pc)) {
105 return false;
106 }
107
108 // Entry frame checks
109 if (is_entry_frame()) {
110 // an entry frame must have a valid fp.
111
112 if (!fp_safe) return false;
113
114 return entry_frame_is_safe(thread);
115 }
116
117 intptr_t* sender_sp = NULL;
118 intptr_t* sender_unextended_sp = NULL;
119 address sender_pc = NULL;
120 intptr_t* saved_fp = NULL;
121
122 if (is_interpreted_frame()) {
123 // fp must be safe
124 if (!fp_safe) {
125 return false;
126 }
127
128 sender_pc = (address) this->fp()[return_addr_offset];
129 // for interpreted frames, the value below is the sender "raw" sp,
130 // which can be different from the sender unextended sp (the sp seen
131 // by the sender) because of current frame local variables
132 sender_sp = (intptr_t*) addr_at(sender_sp_offset);
133 sender_unextended_sp = (intptr_t*) this->fp()[interpreter_frame_sender_sp_offset];
134 saved_fp = (intptr_t*) this->fp()[link_offset];
185
186 // Could just be some random pointer within the codeBlob
187 if (!sender_blob->code_contains(sender_pc)) {
188 return false;
189 }
190
191 // We should never be able to see an adapter if the current frame is something from code cache
192 if (sender_blob->is_adapter_blob()) {
193 return false;
194 }
195
196 // Could be the call_stub
197 if (StubRoutines::returns_to_call_stub(sender_pc)) {
198 bool saved_fp_safe = ((address)saved_fp < thread->stack_base()) && (saved_fp > sender_sp);
199
200 if (!saved_fp_safe) {
201 return false;
202 }
203
204 // construct the potential sender
205 frame sender(sender_sp, sender_unextended_sp, saved_fp, sender_pc);
206 return sender.entry_frame_is_safe(thread);
207 }
208
209 CompiledMethod* nm = sender_blob->as_compiled_method_or_null();
210 if (nm != NULL) {
211 if (nm->is_deopt_mh_entry(sender_pc) || nm->is_deopt_entry(sender_pc) ||
212 nm->method()->is_method_handle_intrinsic()) {
213 return false;
214 }
215 }
216
217 // If the frame size is 0 something (or less) is bad because every nmethod has a non-zero frame size
218 // because the return address counts against the callee's frame.
219
220 if (sender_blob->frame_size() <= 0) {
221 assert(!sender_blob->is_compiled(), "should count return address at least");
222 return false;
223 }
224
225 // We should never be able to see anything here except an nmethod. If something in the
226 // code cache (current frame) is called by an entity within the code cache that entity
|