1 /*
2 * Copyright (c) 2016, 2026, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2016, 2023 SAP SE. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "compiler/oopMap.hpp"
27 #include "interpreter/interpreter.hpp"
28 #include "memory/resourceArea.hpp"
29 #include "memory/universe.hpp"
30 #include "oops/markWord.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "runtime/frame.inline.hpp"
33 #include "runtime/handles.inline.hpp"
34 #include "runtime/javaCalls.hpp"
35 #include "runtime/monitorChunk.hpp"
36 #include "runtime/os.inline.hpp"
37 #include "runtime/signature.hpp"
38 #include "runtime/stubCodeGenerator.hpp"
39 #include "runtime/stubRoutines.hpp"
40 #include "vmreg_s390.inline.hpp"
41 #ifdef COMPILER1
42 #include "c1/c1_Runtime1.hpp"
43 #include "runtime/vframeArray.hpp"
44 #endif
45
46 // Major contributions by Aha, AS.
47
48 #ifdef ASSERT
49 void RegisterMap::check_location_valid() {
50 }
51 #endif // ASSERT
52
53
54 // Profiling/safepoint support
55
56 bool frame::safe_for_sender(JavaThread *thread) {
57 address sp = (address)_sp;
58 address fp = (address)_fp;
59 address unextended_sp = (address)_unextended_sp;
60
61 // consider stack guards when trying to determine "safe" stack pointers
62 // sp must be within the usable part of the stack (not in guards)
63 if (!thread->is_in_usable_stack(sp)) {
64 return false;
65 }
66
67 // Unextended sp must be within the stack
68 if (!thread->is_in_full_stack_checked(unextended_sp)) {
69 return false;
70 }
71
72 // An fp must be within the stack and above (but not equal) sp.
73 bool fp_safe = thread->is_in_stack_range_excl(fp, sp);
74 // An interpreter fp must be fp_safe.
75 // Moreover, it must be at a distance at least the size of the z_ijava_state structure.
76 bool fp_interp_safe = fp_safe && ((fp - sp) >= z_ijava_state_size);
77
78 // We know sp/unextended_sp are safe, only fp is questionable here
79
80 // If the current frame is known to the code cache then we can attempt to
81 // construct the sender and do some validation of it. This goes a long way
82 // toward eliminating issues when we get in frame construction code
83
84 if (_cb != nullptr ) {
85
86 // First check if the frame is complete and the test is reliable.
87 // Unfortunately we can only check frame completeness for runtime stubs.
88 // Other generic buffer blobs are more problematic so we just assume they are OK.
89 // Adapter blobs never have a complete frame and are never OK.
90 // nmethods should be OK on s390.
91 if (!_cb->is_frame_complete_at(_pc)) {
92 if (_cb->is_adapter_blob() || _cb->is_runtime_stub()) {
93 return false;
94 }
95 }
96
97 // Could just be some random pointer within the codeBlob.
98 if (!_cb->code_contains(_pc)) {
99 return false;
100 }
101
102 // Entry frame checks
103 if (is_entry_frame()) {
104 // An entry frame must have a valid fp.
105 return fp_safe && is_entry_frame_valid(thread);
106 }
107
108 if (is_interpreted_frame() && !fp_interp_safe) {
109 return false;
110 }
111
112 // At this point, there still is a chance that fp_safe is false.
113 // In particular, fp might be null. So let's check and
114 // bail out before we actually dereference from fp.
115 if (!fp_safe) {
116 return false;
117 }
118
119 z_common_abi* sender_abi = (z_common_abi*)fp;
120 intptr_t* sender_sp = (intptr_t*) fp;
121 address sender_pc = (address) sender_abi->return_pc;
122
123 // We must always be able to find a recognizable pc.
124 CodeBlob* sender_blob = CodeCache::find_blob(sender_pc);
125 if (sender_blob == nullptr) {
126 return false;
127 }
128
129 // It should be safe to construct the sender though it might not be valid.
130
131 frame sender(sender_sp, sender_pc);
132
133 // Do we have a valid fp?
134 address sender_fp = (address) sender.fp();
135
136 // sender_fp must be within the stack and above (but not
137 // equal) current frame's fp.
138 if (!thread->is_in_stack_range_excl(sender_fp, fp)) {
139 return false;
140 }
141
142 // If the potential sender is the interpreter then we can do some more checking.
143 if (Interpreter::contains(sender_pc)) {
144 return sender.is_interpreted_frame_valid(thread);
145 }
146
147 // Could just be some random pointer within the codeBlob.
148 if (!sender.cb()->code_contains(sender_pc)) {
149 return false;
150 }
151
152 // We should never be able to see an adapter if the current frame is something from code cache.
153 if (sender_blob->is_adapter_blob()) {
154 return false;
155 }
156
157 if (sender.is_entry_frame()) {
158 return sender.is_entry_frame_valid(thread);
159 }
160
161 // Frame size is always greater than zero. If the sender frame size is zero or less,
162 // something is really weird and we better give up.
163 if (sender_blob->frame_size() <= 0) {
164 return false;
165 }
166
167 return true;
168 }
169
170 // Must be native-compiled frame. Since sender will try and use fp to find
171 // linkages it must be safe
172
173 if (!fp_safe) {
174 return false;
175 }
176
177 return true;
178 }
179
180 bool frame::is_interpreted_frame() const {
181 return Interpreter::contains(pc());
182 }
183
184 // locals
185
186 void frame::interpreter_frame_set_locals(intptr_t* locs) {
187 assert(is_interpreted_frame(), "interpreted frame expected");
188 // set relativized locals
189 *addr_at(_z_ijava_idx(locals)) = (intptr_t) (locs - fp());
190 }
191
192 // sender_sp
193
194 intptr_t* frame::interpreter_frame_sender_sp() const {
195 return sender_sp();
196 }
197
198 frame frame::sender_for_entry_frame(RegisterMap *map) const {
199 assert(map != nullptr, "map must be set");
200 // Java frame called from C. Skip all C frames and return top C
201 // frame of that chunk as the sender.
202 JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();
203
204 assert(!entry_frame_is_first(), "next Java sp must be non zero");
205 assert(jfa->last_Java_sp() > _sp, "must be above this frame on stack");
206
207 map->clear();
208
209 assert(map->include_argument_oops(), "should be set by clear");
210
211 if (jfa->last_Java_pc() != nullptr) {
212 frame fr(jfa->last_Java_sp(), jfa->last_Java_pc());
213 return fr;
214 }
215 // Last_java_pc is not set if we come here from compiled code.
216 frame fr(jfa->last_Java_sp());
217 return fr;
218 }
219
220 UpcallStub::FrameData* UpcallStub::frame_data_for_frame(const frame& frame) const {
221 assert(frame.is_upcall_stub_frame(), "wrong frame");
222 // need unextended_sp here, since normal sp is wrong for interpreter callees
223 return reinterpret_cast<UpcallStub::FrameData*>(
224 reinterpret_cast<address>(frame.unextended_sp()) + in_bytes(_frame_data_offset));
225 }
226
227 bool frame::upcall_stub_frame_is_first() const {
228 assert(is_upcall_stub_frame(), "must be optimized entry frame");
229 UpcallStub* blob = _cb->as_upcall_stub();
230 JavaFrameAnchor* jfa = blob->jfa_for_frame(*this);
231 return jfa->last_Java_sp() == nullptr;
232 }
233
234 frame frame::sender_for_upcall_stub_frame(RegisterMap* map) const {
235 assert(map != nullptr, "map must be set");
236 UpcallStub* blob = _cb->as_upcall_stub();
237 // Java frame called from C; skip all C frames and return top C
238 // frame of that chunk as the sender
239 JavaFrameAnchor* jfa = blob->jfa_for_frame(*this);
240 assert(!upcall_stub_frame_is_first(), "must have a frame anchor to go back to");
241 assert(jfa->last_Java_sp() > sp(), "must be above this frame on stack");
242 map->clear();
243 assert(map->include_argument_oops(), "should be set by clear");
244 frame fr(jfa->last_Java_sp(), jfa->last_Java_pc());
245
246 return fr;
247 }
248
249 JavaThread** frame::saved_thread_address(const frame& f) {
250 Unimplemented();
251 return nullptr;
252 }
253
254 frame frame::sender_for_interpreter_frame(RegisterMap *map) const {
255 // Pass callers sender_sp as unextended_sp.
256 return frame(sender_sp(), sender_pc(), (intptr_t*)(ijava_state()->sender_sp));
257 }
258
259 void frame::patch_pc(Thread* thread, address pc) {
260 assert(_cb == CodeCache::find_blob(pc), "unexpected pc");
261 address* pc_addr = (address*)&(own_abi()->return_pc);
262
263 if (TracePcPatching) {
264 tty->print_cr("patch_pc at address " PTR_FORMAT " [" PTR_FORMAT " -> " PTR_FORMAT "] ",
265 p2i(&((address*) _sp)[-1]), p2i(((address*) _sp)[-1]), p2i(pc));
266 }
267 assert(!Continuation::is_return_barrier_entry(*pc_addr), "return barrier");
268 assert(_pc == *pc_addr || pc == *pc_addr || nullptr == *pc_addr,
269 "must be (pc: " INTPTR_FORMAT " _pc: " INTPTR_FORMAT " pc_addr: " INTPTR_FORMAT
270 " *pc_addr: " INTPTR_FORMAT " sp: " INTPTR_FORMAT ")",
271 p2i(pc), p2i(_pc), p2i(pc_addr), p2i(*pc_addr), p2i(sp()));
272 DEBUG_ONLY(address old_pc = _pc;)
273 own_abi()->return_pc = (uint64_t)pc;
274 _pc = pc; // must be set before call to get_deopt_original_pc
275 address original_pc = get_deopt_original_pc();
276 if (original_pc != nullptr) {
277 // assert(original_pc == _pc, "expected original to be stored before patching");
278 _deopt_state = is_deoptimized;
279 _pc = original_pc;
280 } else {
281 _deopt_state = not_deoptimized;
282 }
283 assert(!is_compiled_frame() || !_cb->as_nmethod()->is_deopt_entry(_pc), "must be");
284
285 #ifdef ASSERT
286 {
287 frame f(this->sp(), pc, this->unextended_sp());
288 assert(f.is_deoptimized_frame() == this->is_deoptimized_frame() && f.pc() == this->pc() && f.raw_pc() == this->raw_pc(),
289 "must be (f.is_deoptimized_frame(): %d this->is_deoptimized_frame(): %d "
290 "f.pc(): " INTPTR_FORMAT " this->pc(): " INTPTR_FORMAT " f.raw_pc(): " INTPTR_FORMAT " this->raw_pc(): " INTPTR_FORMAT ")",
291 f.is_deoptimized_frame(), this->is_deoptimized_frame(), p2i(f.pc()), p2i(this->pc()), p2i(f.raw_pc()), p2i(this->raw_pc()));
292 }
293 #endif
294 }
295
296 bool frame::is_interpreted_frame_valid(JavaThread* thread) const {
297 assert(is_interpreted_frame(), "Not an interpreted frame");
298 // These are reasonable sanity checks
299 if (fp() == nullptr || (intptr_t(fp()) & (wordSize-1)) != 0) {
300 return false;
301 }
302 if (sp() == nullptr || (intptr_t(sp()) & (wordSize-1)) != 0) {
303 return false;
304 }
305 int min_frame_slots = (z_common_abi_size + z_ijava_state_size) / sizeof(intptr_t);
306 if (fp() - min_frame_slots < sp()) {
307 return false;
308 }
309 // These are hacks to keep us out of trouble.
310 // The problem with these is that they mask other problems
311 if (fp() <= sp()) { // this attempts to deal with unsigned comparison above
312 return false;
313 }
314
315 // do some validation of frame elements
316
317 // first the method
318 // Need to use "unchecked" versions to avoid "z_istate_magic_number" assertion.
319 Method* m = (Method*)(ijava_state_unchecked()->method);
320
321 // validate the method we'd find in this potential sender
322 if (!Method::is_valid_method(m)) return false;
323
324 // stack frames shouldn't be much larger than max_stack elements
325 // this test requires the use of unextended_sp which is the sp as seen by
326 // the current frame, and not sp which is the "raw" pc which could point
327 // further because of local variables of the callee method inserted after
328 // method arguments
329 if (fp() - unextended_sp() > 1024 + m->max_stack()*Interpreter::stackElementSize) {
330 return false;
331 }
332
333 // validate bci/bcx
334 address bcp = (address)(ijava_state_unchecked()->bcp);
335 if (m->validate_bci_from_bcp(bcp) < 0) {
336 return false;
337 }
338
339 // validate constantPoolCache*
340 ConstantPoolCache* cp = (ConstantPoolCache*)(ijava_state_unchecked()->cpoolCache);
341 if (MetaspaceObj::is_valid(cp) == false) return false;
342
343 // validate locals
344 address locals = (address)interpreter_frame_locals();
345 return thread->is_in_stack_range_incl(locals, (address)fp());
346 }
347
348 BasicType frame::interpreter_frame_result(oop* oop_result, jvalue* value_result) {
349 assert(is_interpreted_frame(), "interpreted frame expected");
350 Method* method = interpreter_frame_method();
351 BasicType type = method->result_type();
352
353 if (method->is_native()) {
354 address lresult = (address)&(ijava_state()->lresult);
355 address fresult = (address)&(ijava_state()->fresult);
356
357 switch (type) {
358 case T_OBJECT:
359 case T_ARRAY: {
360 *oop_result = cast_to_oop((void*) ijava_state()->oop_tmp);
361 break;
362 }
363 // We use std/stfd to store the values.
364 case T_BOOLEAN : value_result->z = (jboolean) *(unsigned long*)lresult; break;
365 case T_INT : value_result->i = (jint) *(long*)lresult; break;
366 case T_CHAR : value_result->c = (jchar) *(unsigned long*)lresult; break;
367 case T_SHORT : value_result->s = (jshort) *(long*)lresult; break;
368 case T_BYTE : value_result->z = (jbyte) *(long*)lresult; break;
369 case T_LONG : value_result->j = (jlong) *(long*)lresult; break;
370 case T_FLOAT : value_result->f = (jfloat) *(float*)fresult; break;
371 case T_DOUBLE : value_result->d = (jdouble) *(double*)fresult; break;
372 case T_VOID : break; // Nothing to do.
373 default : ShouldNotReachHere();
374 }
375 } else {
376 intptr_t* tos_addr = interpreter_frame_tos_address();
377 switch (type) {
378 case T_OBJECT:
379 case T_ARRAY: {
380 oop obj = *(oop*)tos_addr;
381 assert(Universe::is_in_heap_or_null(obj), "sanity check");
382 *oop_result = obj;
383 break;
384 }
385 case T_BOOLEAN : value_result->z = (jboolean) *(jint*)tos_addr; break;
386 case T_BYTE : value_result->b = (jbyte) *(jint*)tos_addr; break;
387 case T_CHAR : value_result->c = (jchar) *(jint*)tos_addr; break;
388 case T_SHORT : value_result->s = (jshort) *(jint*)tos_addr; break;
389 case T_INT : value_result->i = *(jint*)tos_addr; break;
390 case T_LONG : value_result->j = *(jlong*)tos_addr; break;
391 case T_FLOAT : value_result->f = *(jfloat*)tos_addr; break;
392 case T_DOUBLE : value_result->d = *(jdouble*)tos_addr; break;
393 case T_VOID : break; // Nothing to do.
394 default : ShouldNotReachHere();
395 }
396 }
397
398 return type;
399 }
400
401
402 // Dump all frames starting a given C stack-pointer.
403 // Use max_frames to limit the number of traced frames.
404 void frame::back_trace(outputStream* st, intptr_t* start_sp, intptr_t* top_pc, unsigned long flags, int max_frames) {
405
406 static char buf[ 150 ];
407
408 bool print_outgoing_arguments = flags & 0x1;
409 bool print_istate_pointers = flags & 0x2;
410 int num = 0;
411
412 intptr_t* current_sp = (intptr_t*) start_sp;
413 int last_num_jargs = 0;
414 int frame_type = 0;
415 int last_frame_type = 0;
416
417 while (current_sp) {
418 intptr_t* current_fp = (intptr_t*) *current_sp;
419 address current_pc = (num == 0)
420 ? (address) top_pc
421 : (address) *((intptr_t*)(((address) current_sp) + _z_abi(return_pc)));
422
423 if ((intptr_t*) current_fp != nullptr && (intptr_t*) current_fp <= current_sp) {
424 st->print_cr("ERROR: corrupt stack");
425 return;
426 }
427
428 st->print("#%-3d ", num);
429 const char* type_name = " ";
430 const char* function_name = nullptr;
431
432 // Detect current frame's frame_type, default to 'C frame'.
433 frame_type = 0;
434
435 CodeBlob* blob = nullptr;
436
437 if (Interpreter::contains(current_pc)) {
438 frame_type = 1;
439 } else if (StubRoutines::contains(current_pc)) {
440 if (StubRoutines::returns_to_call_stub(current_pc)) {
441 frame_type = 2;
442 } else {
443 frame_type = 4;
444 type_name = "stu";
445 StubCodeDesc* desc = StubCodeDesc::desc_for (current_pc);
446 if (desc) {
447 function_name = desc->name();
448 } else {
449 function_name = "unknown stub";
450 }
451 }
452 } else if (CodeCache::contains(current_pc)) {
453 blob = CodeCache::find_blob(current_pc);
454 if (blob) {
455 if (blob->is_nmethod()) {
456 frame_type = 3;
457 } else if (blob->is_deoptimization_stub()) {
458 frame_type = 4;
459 type_name = "deo";
460 function_name = "deoptimization blob";
461 } else if (blob->is_uncommon_trap_stub()) {
462 frame_type = 4;
463 type_name = "uct";
464 function_name = "uncommon trap blob";
465 } else if (blob->is_exception_stub()) {
466 frame_type = 4;
467 type_name = "exc";
468 function_name = "exception blob";
469 } else if (blob->is_safepoint_stub()) {
470 frame_type = 4;
471 type_name = "saf";
472 function_name = "safepoint blob";
473 } else if (blob->is_runtime_stub()) {
474 frame_type = 4;
475 type_name = "run";
476 function_name = ((RuntimeStub *)blob)->name();
477 } else if (blob->is_method_handles_adapter_blob()) {
478 frame_type = 4;
479 type_name = "mha";
480 function_name = "method handles adapter blob";
481 } else {
482 frame_type = 4;
483 type_name = "blo";
484 function_name = "unknown code blob";
485 }
486 } else {
487 frame_type = 4;
488 type_name = "blo";
489 function_name = "unknown code blob";
490 }
491 }
492
493 st->print("sp=" PTR_FORMAT " ", p2i(current_sp));
494
495 if (frame_type == 0) {
496 current_pc = (address) *((intptr_t*)(((address) current_sp) + _z_abi(gpr14)));
497 }
498
499 st->print("pc=" PTR_FORMAT " ", p2i(current_pc));
500 st->print(" ");
501
502 switch (frame_type) {
503 case 0: // C frame:
504 {
505 st->print(" ");
506 if (current_pc == nullptr) {
507 st->print("? ");
508 } else {
509 // name
510 int func_offset;
511 char demangled_name[256];
512 int demangled_name_len = 256;
513 if (os::dll_address_to_function_name(current_pc, demangled_name, demangled_name_len, &func_offset)) {
514 demangled_name[demangled_name_len-1] = '\0';
515 st->print(func_offset == -1 ? "%s " : "%s+0x%x", demangled_name, func_offset);
516 } else {
517 st->print("? ");
518 }
519 }
520 }
521 break;
522
523 case 1: // interpreter frame:
524 {
525 st->print(" i ");
526
527 if (last_frame_type != 1) last_num_jargs = 8;
528
529 // name
530 Method* method = *(Method**)((address)current_fp + _z_ijava_state_neg(method));
531 if (method) {
532 ResourceMark rm;
533 if (method->is_synchronized()) st->print("synchronized ");
534 if (method->is_static()) st->print("static ");
535 if (method->is_native()) st->print("native ");
536 method->name_and_sig_as_C_string(buf, sizeof(buf));
537 st->print("%s ", buf);
538 }
539 else
540 st->print("? ");
541
542 intptr_t* tos = (intptr_t*) *(intptr_t*)((address)current_fp + _z_ijava_state_neg(esp));
543 if (print_istate_pointers) {
544 st->cr();
545 st->print(" ");
546 st->print("ts=" PTR_FORMAT " ", p2i(tos));
547 }
548
549 // Dump some Java stack slots.
550 if (print_outgoing_arguments) {
551 if (method->is_native()) {
552 #ifdef ASSERT
553 intptr_t* cargs = (intptr_t*) (((address)current_sp) + _z_abi(carg_1));
554 for (int i = 0; i < last_num_jargs; i++) {
555 // Cargs is not prepushed.
556 st->cr();
557 st->print(" ");
558 st->print(PTR_FORMAT, *(cargs));
559 cargs++;
560 }
561 #endif /* ASSERT */
562 }
563 else {
564 if (tos) {
565 for (int i = 0; i < last_num_jargs; i++) {
566 // tos+0 is prepushed, ignore.
567 tos++;
568 if (tos >= (intptr_t *)((address)current_fp + _z_ijava_state_neg(monitors)))
569 break;
570 st->cr();
571 st->print(" ");
572 st->print(PTR_FORMAT " %+.3e %+.3le", *(tos), *(float*)(tos), *(double*)(tos));
573 }
574 }
575 }
576 last_num_jargs = method->size_of_parameters();
577 }
578 }
579 break;
580
581 case 2: // entry frame:
582 {
583 st->print("v2i ");
584
585 // name
586 st->print("call stub");
587 }
588 break;
589
590 case 3: // compiled frame:
591 {
592 st->print(" c ");
593
594 // name
595 Method* method = ((nmethod *)blob)->method();
596 if (method) {
597 ResourceMark rm;
598 method->name_and_sig_as_C_string(buf, sizeof(buf));
599 st->print("%s ", buf);
600 }
601 else
602 st->print("? ");
603 }
604 break;
605
606 case 4: // named frames
607 {
608 st->print("%s ", type_name);
609
610 // name
611 if (function_name)
612 st->print("%s", function_name);
613 }
614 break;
615
616 default:
617 break;
618 }
619
620 st->cr();
621 st->flush();
622
623 current_sp = current_fp;
624 last_frame_type = frame_type;
625 num++;
626 // Check for maximum # of frames, and stop when reached.
627 if (max_frames > 0 && --max_frames == 0)
628 break;
629 }
630
631 }
632
633 // Convenience function for calls from the debugger.
634
635 extern "C" void bt(intptr_t* start_sp,intptr_t* top_pc) {
636 frame::back_trace(tty,start_sp, top_pc, 0);
637 }
638
639 extern "C" void bt_full(intptr_t* start_sp,intptr_t* top_pc) {
640 frame::back_trace(tty,start_sp, top_pc, (unsigned long)(long)-1);
641 }
642
643
644 // Function for tracing a limited number of frames.
645 // Use this one if you only need to see the "top of stack" frames.
646 extern "C" void bt_max(intptr_t *start_sp, intptr_t *top_pc, int max_frames) {
647 frame::back_trace(tty, start_sp, top_pc, 0, max_frames);
648 }
649
650 #if !defined(PRODUCT)
651
652 #define DESCRIBE_ADDRESS(name) \
653 values.describe(frame_no, (intptr_t*)&ijava_state()->name, #name);
654
655 void frame::describe_pd(FrameValues& values, int frame_no) {
656 if (is_interpreted_frame()) {
657 // Describe z_ijava_state elements.
658 DESCRIBE_ADDRESS(method);
659 DESCRIBE_ADDRESS(locals);
660 DESCRIBE_ADDRESS(monitors);
661 DESCRIBE_ADDRESS(cpoolCache);
662 DESCRIBE_ADDRESS(bcp);
663 DESCRIBE_ADDRESS(mdx);
664 DESCRIBE_ADDRESS(esp);
665 DESCRIBE_ADDRESS(sender_sp);
666 DESCRIBE_ADDRESS(top_frame_sp);
667 DESCRIBE_ADDRESS(oop_tmp);
668 DESCRIBE_ADDRESS(lresult);
669 DESCRIBE_ADDRESS(fresult);
670 }
671 }
672
673 #endif // !PRODUCT
674
675 intptr_t *frame::initial_deoptimization_info() {
676 // Used to reset the saved FP.
677 return fp();
678 }
679
680 BasicObjectLock* frame::interpreter_frame_monitor_end() const {
681 return interpreter_frame_monitors();
682 }
683
684 intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
685 return &interpreter_frame_tos_address()[offset];
686 }
687
688 intptr_t* frame::repair_sender_sp(intptr_t* sender_sp, intptr_t** saved_fp_addr) const {
689 Unimplemented();
690 return nullptr;
691 }
692
693 intptr_t* frame::repair_sender_sp(nmethod* nm, intptr_t* sp, intptr_t** saved_fp_addr) {
694 Unimplemented();
695 return nullptr;
696 }
697
698 bool frame::was_augmented_on_entry(int& real_size) const {
699 Unimplemented();
700 return false;
701 }