1 /*
2 * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2014, Red Hat Inc. 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 #ifndef CPU_AARCH64_FRAME_AARCH64_INLINE_HPP
27 #define CPU_AARCH64_FRAME_AARCH64_INLINE_HPP
28
29 #include "code/codeBlob.inline.hpp"
30 #include "code/codeCache.inline.hpp"
31 #include "code/vmreg.inline.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "runtime/sharedRuntime.hpp"
34 #include "pauth_aarch64.hpp"
35
36 // Inline functions for AArch64 frames:
37
38 #if INCLUDE_JFR
39
40 // Static helper routines
41
42 inline address frame::interpreter_bcp(const intptr_t* fp) {
43 assert(fp != nullptr, "invariant");
44 return reinterpret_cast<address>(fp[frame::interpreter_frame_bcp_offset]);
45 }
46
47 inline address frame::interpreter_return_address(const intptr_t* fp) {
48 assert(fp != nullptr, "invariant");
49 return reinterpret_cast<address>(fp[frame::return_addr_offset]);
50 }
51
52 inline intptr_t* frame::interpreter_sender_sp(const intptr_t* fp) {
53 assert(fp != nullptr, "invariant");
54 return reinterpret_cast<intptr_t*>(fp[frame::interpreter_frame_sender_sp_offset]);
55 }
56
57 inline bool frame::is_interpreter_frame_setup_at(const intptr_t* fp, const void* sp) {
58 assert(fp != nullptr, "invariant");
59 assert(sp != nullptr, "invariant");
60 return sp <= fp + frame::interpreter_frame_initial_sp_offset;
61 }
62
63 inline intptr_t* frame::sender_sp(intptr_t* fp) {
64 assert(fp != nullptr, "invariant");
65 return fp + frame::sender_sp_offset;
66 }
67
68 inline intptr_t* frame::link(const intptr_t* fp) {
69 assert(fp != nullptr, "invariant");
70 return reinterpret_cast<intptr_t*>(fp[frame::link_offset]);
71 }
72
73 inline address frame::return_address(const intptr_t* sp) {
74 assert(sp != nullptr, "invariant");
75 return reinterpret_cast<address>(sp[-1]);
76 }
77
78 inline intptr_t* frame::fp(const intptr_t* sp) {
79 assert(sp != nullptr, "invariant");
80 return reinterpret_cast<intptr_t*>(sp[-2]);
81 }
82
83 #endif // INCLUDE_JFR
84
85 // Constructors:
86
87 inline frame::frame() {
88 _pc = nullptr;
89 _sp = nullptr;
90 _unextended_sp = nullptr;
91 _fp = nullptr;
92 _cb = nullptr;
93 _deopt_state = unknown;
94 _sp_is_trusted = false;
95 _on_heap = false;
96 DEBUG_ONLY(_frame_index = -1;)
97 }
98
99 static int spin;
100
101 inline void frame::init(intptr_t* sp, intptr_t* fp, address pc) {
102 assert(pauth_ptr_is_raw(pc), "cannot be signed");
103 intptr_t a = intptr_t(sp);
104 intptr_t b = intptr_t(fp);
105 _sp = sp;
106 _unextended_sp = sp;
107 _fp = fp;
108 _pc = pc;
109 _oop_map = nullptr;
110 _on_heap = false;
111 DEBUG_ONLY(_frame_index = -1;)
112
113 assert(pc != nullptr, "no pc?");
114 _cb = CodeCache::find_blob(pc);
115 setup(pc);
116 }
117
118 inline void frame::setup(address pc) {
119 adjust_unextended_sp();
120
121 address original_pc = get_deopt_original_pc();
122 if (original_pc != nullptr) {
123 _pc = original_pc;
124 _deopt_state = is_deoptimized;
125 assert(_cb == nullptr || _cb->as_nmethod()->insts_contains_inclusive(_pc),
126 "original PC must be in the main code section of the compiled method (or must be immediately following it)");
127 } else {
128 if (_cb == SharedRuntime::deopt_blob()) {
129 _deopt_state = is_deoptimized;
130 } else {
131 _deopt_state = not_deoptimized;
132 }
133 }
134 _sp_is_trusted = false;
135 }
136
137 inline frame::frame(intptr_t* sp, intptr_t* fp, address pc) {
138 init(sp, fp, pc);
139 }
140
141 inline frame::frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb, bool allow_cb_null) {
142 assert(pauth_ptr_is_raw(pc), "cannot be signed");
143 intptr_t a = intptr_t(sp);
144 intptr_t b = intptr_t(fp);
145 _sp = sp;
146 _unextended_sp = unextended_sp;
147 _fp = fp;
148 _pc = pc;
149 assert(pc != nullptr, "no pc?");
150 _cb = cb;
151 _oop_map = nullptr;
152 assert(_cb != nullptr || allow_cb_null, "pc: " INTPTR_FORMAT, p2i(pc));
153 _on_heap = false;
154 DEBUG_ONLY(_frame_index = -1;)
155
156 setup(pc);
157 }
158
159 inline frame::frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb, const ImmutableOopMap* oop_map, bool on_heap) {
160 _sp = sp;
161 _unextended_sp = unextended_sp;
162 _fp = fp;
163 _pc = pc;
164 _cb = cb;
165 _oop_map = oop_map;
166 _deopt_state = not_deoptimized;
167 _sp_is_trusted = false;
168 _on_heap = on_heap;
169 DEBUG_ONLY(_frame_index = -1;)
170
171 // In thaw, non-heap frames use this constructor to pass oop_map. I don't know why.
172 assert(_on_heap || _cb != nullptr, "these frames are always heap frames");
173 if (cb != nullptr) {
174 setup(pc);
175 }
176 #ifdef ASSERT
177 // The following assertion has been disabled because it would sometime trap for Continuation.run,
178 // which is not *in* a continuation and therefore does not clear the _cont_fastpath flag, but this
179 // is benign even in fast mode (see Freeze::setup_jump)
180 // We might freeze deoptimized frame in slow mode
181 // assert(_pc == pc && _deopt_state == not_deoptimized, "");
182 #endif
183 }
184
185 inline frame::frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc) {
186 intptr_t a = intptr_t(sp);
187 intptr_t b = intptr_t(fp);
188 _sp = sp;
189 _unextended_sp = unextended_sp;
190 _fp = fp;
191 _pc = pc;
192 _cb = CodeCache::find_blob_fast(pc);
193 _oop_map = nullptr;
194 assert(_cb != nullptr, "pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " unextended_sp: " INTPTR_FORMAT " fp: " INTPTR_FORMAT, p2i(pc), p2i(sp), p2i(unextended_sp), p2i(fp));
195 _on_heap = false;
196 DEBUG_ONLY(_frame_index = -1;)
197
198 setup(pc);
199 }
200
201 inline frame::frame(intptr_t* sp)
202 : frame(sp, sp,
203 *(intptr_t**)(sp - frame::sender_sp_offset),
204 pauth_strip_verifiable(*(address*)(sp - 1))) {}
205
206 inline frame::frame(intptr_t* sp, intptr_t* fp) {
207 intptr_t a = intptr_t(sp);
208 intptr_t b = intptr_t(fp);
209 _sp = sp;
210 _unextended_sp = sp;
211 _fp = fp;
212 _pc = (address)(sp[-1]);
213 _on_heap = false;
214 DEBUG_ONLY(_frame_index = -1;)
215
216 // Here's a sticky one. This constructor can be called via AsyncGetCallTrace
217 // when last_Java_sp is non-null but the pc fetched is junk.
218 // AsyncGetCallTrace -> pd_get_top_frame_for_signal_handler
219 // -> pd_last_frame should use a specialized version of pd_last_frame which could
220 // call a specilaized frame constructor instead of this one.
221 // Then we could use the assert below. However this assert is of somewhat dubious
222 // value.
223 // assert(_pc != nullptr, "no pc?");
224
225 _cb = CodeCache::find_blob(_pc);
226 adjust_unextended_sp();
227
228 address original_pc = get_deopt_original_pc();
229 if (original_pc != nullptr) {
230 _pc = original_pc;
231 _deopt_state = is_deoptimized;
232 } else {
233 _deopt_state = not_deoptimized;
234 }
235 _sp_is_trusted = false;
236 }
237
238 // Accessors
239
240 inline bool frame::equal(frame other) const {
241 bool ret = sp() == other.sp()
242 && unextended_sp() == other.unextended_sp()
243 && fp() == other.fp()
244 && pc() == other.pc();
245 assert(!ret || (cb() == other.cb() && _deopt_state == other._deopt_state), "inconsistent construction");
246 return ret;
247 }
248
249 // Return unique id for this frame. The id must have a value where we can distinguish
250 // identity and younger/older relationship. null represents an invalid (incomparable)
251 // frame.
252 inline intptr_t* frame::id(void) const { return unextended_sp(); }
253
254 // Return true if the frame is older (less recent activation) than the frame represented by id
255 inline bool frame::is_older(intptr_t* id) const { assert(this->id() != nullptr && id != nullptr, "null frame id");
256 return this->id() > id ; }
257
258 inline intptr_t* frame::link() const { return (intptr_t*) *(intptr_t **)addr_at(link_offset); }
259
260 inline intptr_t* frame::link_or_null() const {
261 intptr_t** ptr = (intptr_t **)addr_at(link_offset);
262 return os::is_readable_pointer(ptr) ? *ptr : nullptr;
263 }
264
265 inline intptr_t* frame::unextended_sp() const { assert_absolute(); return _unextended_sp; }
266 inline void frame::set_unextended_sp(intptr_t* value) { _unextended_sp = value; }
267 inline int frame::offset_unextended_sp() const { assert_offset(); return _offset_unextended_sp; }
268 inline void frame::set_offset_unextended_sp(int value) { assert_on_heap(); _offset_unextended_sp = value; }
269
270 inline intptr_t* frame::real_fp() const {
271 if (_cb != nullptr) {
272 // use the frame size if valid
273 int size = _cb->frame_size();
274 if (size > 0) {
275 return unextended_sp() + size;
276 }
277 }
278 // else rely on fp()
279 assert(! is_compiled_frame(), "unknown compiled frame size");
280 return fp();
281 }
282
283 inline int frame::frame_size() const {
284 return is_interpreted_frame()
285 ? pointer_delta_as_int(sender_sp(), sp())
286 : cb()->frame_size();
287 }
288
289 inline int frame::compiled_frame_stack_argsize() const {
290 assert(cb()->is_nmethod(), "");
291 return (cb()->as_nmethod()->num_stack_arg_slots() * VMRegImpl::stack_slot_size) >> LogBytesPerWord;
292 }
293
294 inline void frame::interpreted_frame_oop_map(InterpreterOopMap* mask) const {
295 assert(mask != nullptr, "");
296 Method* m = interpreter_frame_method();
297 int bci = interpreter_frame_bci();
298 m->mask_for(bci, mask); // OopMapCache::compute_one_oop_map(m, bci, mask);
299 }
300
301 // Return address:
302
303 inline address* frame::sender_pc_addr() const { return (address*) addr_at( return_addr_offset); }
304 inline address frame::sender_pc_maybe_signed() const { return *sender_pc_addr(); }
305 inline address frame::sender_pc() const { return pauth_strip_pointer(sender_pc_maybe_signed()); }
306
307 inline intptr_t* frame::sender_sp() const { return addr_at( sender_sp_offset); }
308
309 inline intptr_t* frame::interpreter_frame_locals() const {
310 intptr_t n = *addr_at(interpreter_frame_locals_offset);
311 return &fp()[n]; // return relativized locals
312 }
313
314 inline intptr_t* frame::interpreter_frame_last_sp() const {
315 intptr_t n = *addr_at(interpreter_frame_last_sp_offset);
316 assert(n <= 0, "n: " INTPTR_FORMAT, n);
317 return n != 0 ? &fp()[n] : nullptr;
318 }
319
320 inline intptr_t* frame::interpreter_frame_bcp_addr() const {
321 return (intptr_t*)addr_at(interpreter_frame_bcp_offset);
322 }
323
324 inline intptr_t* frame::interpreter_frame_mdp_addr() const {
325 return (intptr_t*)addr_at(interpreter_frame_mdp_offset);
326 }
327
328
329 // Constant pool cache
330
331 inline ConstantPoolCache** frame::interpreter_frame_cache_addr() const {
332 return (ConstantPoolCache**)addr_at(interpreter_frame_cache_offset);
333 }
334
335 // Method
336
337 inline Method** frame::interpreter_frame_method_addr() const {
338 return (Method**)addr_at(interpreter_frame_method_offset);
339 }
340
341 // Mirror
342
343 inline oop* frame::interpreter_frame_mirror_addr() const {
344 return (oop*)addr_at(interpreter_frame_mirror_offset);
345 }
346
347 // top of expression stack
348 inline intptr_t* frame::interpreter_frame_tos_address() const {
349 intptr_t* last_sp = interpreter_frame_last_sp();
350 if (last_sp == nullptr) {
351 return sp();
352 } else {
353 // sp() may have been extended or shrunk by an adapter. At least
354 // check that we don't fall behind the legal region.
355 // For top deoptimized frame last_sp == interpreter_frame_monitor_end.
356 assert(last_sp <= (intptr_t*) interpreter_frame_monitor_end(), "bad tos");
357 return last_sp;
358 }
359 }
360
361 inline oop* frame::interpreter_frame_temp_oop_addr() const {
362 return (oop *)(fp() + interpreter_frame_oop_temp_offset);
363 }
364
365 inline int frame::interpreter_frame_monitor_size() {
366 return BasicObjectLock::size();
367 }
368
369
370 // expression stack
371 // (the max_stack arguments are used by the GC; see class FrameClosure)
372
373 inline intptr_t* frame::interpreter_frame_expression_stack() const {
374 intptr_t* monitor_end = (intptr_t*) interpreter_frame_monitor_end();
375 return monitor_end-1;
376 }
377
378
379 // Entry frames
380
381 inline JavaCallWrapper** frame::entry_frame_call_wrapper_addr() const {
382 return (JavaCallWrapper**)addr_at(entry_frame_call_wrapper_offset);
383 }
384
385
386 // Compiled frames
387
388 inline oop frame::saved_oop_result(RegisterMap* map) const {
389 oop* result_adr = (oop *)map->location(r0->as_VMReg(), sp());
390 guarantee(result_adr != nullptr, "bad register save location");
391 return *result_adr;
392 }
393
394 inline void frame::set_saved_oop_result(RegisterMap* map, oop obj) {
395 oop* result_adr = (oop *)map->location(r0->as_VMReg(), sp());
396 guarantee(result_adr != nullptr, "bad register save location");
397
398 *result_adr = obj;
399 }
400
401 inline bool frame::is_interpreted_frame() const {
402 return Interpreter::contains(pc());
403 }
404
405 inline int frame::sender_sp_ret_address_offset() {
406 return frame::sender_sp_offset - frame::return_addr_offset;
407 }
408
409 //------------------------------------------------------------------------------
410 // frame::sender
411 inline frame frame::sender(RegisterMap* map) const {
412 frame result = sender_raw(map);
413
414 if (map->process_frames() && !map->in_cont()) {
415 StackWatermarkSet::on_iteration(map->thread(), result);
416 }
417
418 return result;
419 }
420
421 inline frame frame::sender_raw(RegisterMap* map) const {
422 // Default is we done have to follow them. The sender_for_xxx will
423 // update it accordingly
424 map->set_include_argument_oops(false);
425
426 if (map->in_cont()) { // already in an h-stack
427 return map->stack_chunk()->sender(*this, map);
428 }
429
430 if (is_entry_frame()) return sender_for_entry_frame(map);
431 if (is_upcall_stub_frame()) return sender_for_upcall_stub_frame(map);
432 if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
433
434 assert(_cb == CodeCache::find_blob(pc()), "Must be the same");
435 if (_cb != nullptr) return sender_for_compiled_frame(map);
436
437 // Must be native-compiled frame, i.e. the marshaling code for native
438 // methods that exists in the core system.
439
440 // Native code may or may not have signed the return address, we have no way to be sure or what
441 // signing methods they used. Instead, just ensure the stripped value is used.
442
443 return frame(sender_sp(), link(), sender_pc());
444 }
445
446 inline frame frame::sender_for_compiled_frame(RegisterMap* map) const {
447 // we cannot rely upon the last fp having been saved to the thread
448 // in C2 code but it will have been pushed onto the stack. so we
449 // have to find it relative to the unextended sp
450
451 assert(_cb->frame_size() > 0, "must have non-zero frame size");
452 intptr_t* l_sender_sp = (!PreserveFramePointer || _sp_is_trusted) ? unextended_sp() + _cb->frame_size()
453 : sender_sp();
454 assert(!_sp_is_trusted || l_sender_sp == real_fp(), "");
455
456 // The return_address is always the word on the stack.
457 // For ROP protection, C1/C2 will have signed the sender_pc,
458 // but there is no requirement to authenticate it here.
459 address sender_pc = pauth_strip_verifiable((address) *(l_sender_sp - 1));
460
461 intptr_t** saved_fp_addr = (intptr_t**) (l_sender_sp - frame::sender_sp_offset);
462
463 if (map->update_map()) {
464 // Tell GC to use argument oopmaps for some runtime stubs that need it.
465 // For C1, the runtime stub might not have oop maps, so set this flag
466 // outside of update_register_map.
467 if (!_cb->is_nmethod()) { // compiled frames do not use callee-saved registers
468 map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
469 if (oop_map() != nullptr) {
470 _oop_map->update_register_map(this, map);
471 }
472 } else {
473 assert(!_cb->caller_must_gc_arguments(map->thread()), "");
474 assert(!map->include_argument_oops(), "");
475 assert(oop_map() == nullptr || !oop_map()->has_any(OopMapValue::callee_saved_value), "callee-saved value in compiled frame");
476 }
477
478 // Since the prolog does the save and restore of FP there is no oopmap
479 // for it so we must fill in its location as if there was an oopmap entry
480 // since if our caller was compiled code there could be live jvm state in it.
481 update_map_with_saved_link(map, saved_fp_addr);
482 }
483
484 if (Continuation::is_return_barrier_entry(sender_pc)) {
485 if (map->walk_cont()) { // about to walk into an h-stack
486 return Continuation::top_frame(*this, map);
487 } else {
488 return Continuation::continuation_bottom_sender(map->thread(), *this, l_sender_sp);
489 }
490 }
491
492 intptr_t* unextended_sp = l_sender_sp;
493 return frame(l_sender_sp, unextended_sp, *saved_fp_addr, sender_pc);
494 }
495
496 template <typename RegisterMapT>
497 void frame::update_map_with_saved_link(RegisterMapT* map, intptr_t** link_addr) {
498 // The interpreter and compiler(s) always save FP in a known
499 // location on entry. C2-compiled code uses FP as an allocatable
500 // callee-saved register. We must record where that location is so
501 // that if FP was live on callout from c2 we can find the saved copy.
502
503 map->set_location(rfp->as_VMReg(), (address) link_addr);
504 // this is weird "H" ought to be at a higher address however the
505 // oopMaps seems to have the "H" regs at the same address and the
506 // vanilla register.
507 // XXXX make this go away
508 if (true) {
509 map->set_location(rfp->as_VMReg()->next(), (address) link_addr);
510 }
511 }
512 #endif // CPU_AARCH64_FRAME_AARCH64_INLINE_HPP