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