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
|