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 // Constructors:
39
40 inline frame::frame() {
41 _pc = nullptr;
42 _sp = nullptr;
43 _unextended_sp = nullptr;
44 _fp = nullptr;
45 _cb = nullptr;
46 _deopt_state = unknown;
47 _sp_is_trusted = false;
48 _on_heap = false;
49 DEBUG_ONLY(_frame_index = -1;)
50 }
51
52 static int spin;
53
54 inline void frame::init(intptr_t* sp, intptr_t* fp, address pc) {
401 assert(_cb == CodeCache::find_blob(pc()), "Must be the same");
402 if (_cb != nullptr) return sender_for_compiled_frame(map);
403
404 // Must be native-compiled frame, i.e. the marshaling code for native
405 // methods that exists in the core system.
406
407 // Native code may or may not have signed the return address, we have no way to be sure or what
408 // signing methods they used. Instead, just ensure the stripped value is used.
409
410 return frame(sender_sp(), link(), sender_pc());
411 }
412
413 inline frame frame::sender_for_compiled_frame(RegisterMap* map) const {
414 // we cannot rely upon the last fp having been saved to the thread
415 // in C2 code but it will have been pushed onto the stack. so we
416 // have to find it relative to the unextended sp
417
418 assert(_cb->frame_size() > 0, "must have non-zero frame size");
419 intptr_t* l_sender_sp = (!PreserveFramePointer || _sp_is_trusted) ? unextended_sp() + _cb->frame_size()
420 : sender_sp();
421 assert(!_sp_is_trusted || l_sender_sp == real_fp(), "");
422
423 // The return_address is always the word on the stack.
424 // For ROP protection, C1/C2 will have signed the sender_pc,
425 // but there is no requirement to authenticate it here.
426 address sender_pc = pauth_strip_verifiable((address) *(l_sender_sp - 1));
427
428 intptr_t** saved_fp_addr = (intptr_t**) (l_sender_sp - frame::sender_sp_offset);
429
430 if (map->update_map()) {
431 // Tell GC to use argument oopmaps for some runtime stubs that need it.
432 // For C1, the runtime stub might not have oop maps, so set this flag
433 // outside of update_register_map.
434 if (!_cb->is_compiled()) { // compiled frames do not use callee-saved registers
435 map->set_include_argument_oops(_cb->caller_must_gc_arguments(map->thread()));
436 if (oop_map() != nullptr) {
437 _oop_map->update_register_map(this, map);
438 }
439 } else {
440 assert(!_cb->caller_must_gc_arguments(map->thread()), "");
441 assert(!map->include_argument_oops(), "");
442 assert(oop_map() == nullptr || !oop_map()->has_any(OopMapValue::callee_saved_value), "callee-saved value in compiled frame");
443 }
444
445 // Since the prolog does the save and restore of FP there is no oopmap
446 // for it so we must fill in its location as if there was an oopmap entry
447 // since if our caller was compiled code there could be live jvm state in it.
448 update_map_with_saved_link(map, saved_fp_addr);
449 }
450
451 if (Continuation::is_return_barrier_entry(sender_pc)) {
452 if (map->walk_cont()) { // about to walk into an h-stack
453 return Continuation::top_frame(*this, map);
454 } else {
455 return Continuation::continuation_bottom_sender(map->thread(), *this, l_sender_sp);
|
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 #ifdef COMPILER1
36 #include "c1/c1_Runtime1.hpp"
37 #endif
38
39 // Inline functions for AArch64 frames:
40
41 // Constructors:
42
43 inline frame::frame() {
44 _pc = nullptr;
45 _sp = nullptr;
46 _unextended_sp = nullptr;
47 _fp = nullptr;
48 _cb = nullptr;
49 _deopt_state = unknown;
50 _sp_is_trusted = false;
51 _on_heap = false;
52 DEBUG_ONLY(_frame_index = -1;)
53 }
54
55 static int spin;
56
57 inline void frame::init(intptr_t* sp, intptr_t* fp, address pc) {
404 assert(_cb == CodeCache::find_blob(pc()), "Must be the same");
405 if (_cb != nullptr) return sender_for_compiled_frame(map);
406
407 // Must be native-compiled frame, i.e. the marshaling code for native
408 // methods that exists in the core system.
409
410 // Native code may or may not have signed the return address, we have no way to be sure or what
411 // signing methods they used. Instead, just ensure the stripped value is used.
412
413 return frame(sender_sp(), link(), sender_pc());
414 }
415
416 inline frame frame::sender_for_compiled_frame(RegisterMap* map) const {
417 // we cannot rely upon the last fp having been saved to the thread
418 // in C2 code but it will have been pushed onto the stack. so we
419 // have to find it relative to the unextended sp
420
421 assert(_cb->frame_size() > 0, "must have non-zero frame size");
422 intptr_t* l_sender_sp = (!PreserveFramePointer || _sp_is_trusted) ? unextended_sp() + _cb->frame_size()
423 : sender_sp();
424 #ifdef ASSERT
425 address sender_pc_copy = pauth_strip_verifiable((address) *(l_sender_sp-1));
426 #endif
427
428 assert(!_sp_is_trusted || l_sender_sp == real_fp(), "");
429
430 intptr_t** saved_fp_addr = (intptr_t**) (l_sender_sp - frame::sender_sp_offset);
431
432 // Repair the sender sp if the frame has been extended
433 l_sender_sp = repair_sender_sp(l_sender_sp, saved_fp_addr);
434
435 // The return_address is always the word on the stack.
436 // For ROP protection, C1/C2 will have signed the sender_pc,
437 // but there is no requirement to authenticate it here.
438 address sender_pc = pauth_strip_verifiable((address) *(l_sender_sp - 1));
439
440 #ifdef ASSERT
441 if (sender_pc != sender_pc_copy) {
442 // When extending the stack in the callee method entry to make room for unpacking of value
443 // type args, we keep a copy of the sender pc at the expected location in the callee frame.
444 // If the sender pc is patched due to deoptimization, the copy is not consistent anymore.
445 nmethod* nm = CodeCache::find_blob(sender_pc)->as_nmethod();
446 assert(sender_pc == nm->deopt_mh_handler_begin() || sender_pc == nm->deopt_handler_begin(), "unexpected sender pc");
447 }
448 #endif
449
450 if (map->update_map()) {
451 // Tell GC to use argument oopmaps for some runtime stubs that need it.
452 // For C1, the runtime stub might not have oop maps, so set this flag
453 // outside of update_register_map.
454 bool c1_buffering = false;
455 #ifdef COMPILER1
456 nmethod* nm = _cb->as_nmethod_or_null();
457 if (nm != nullptr && nm->is_compiled_by_c1() && nm->method()->has_scalarized_args() &&
458 pc() < nm->verified_inline_entry_point()) {
459 // The VEP and VIEP(RO) of C1-compiled methods call buffer_inline_args_xxx
460 // before doing any argument shuffling, so we need to scan the oops
461 // as the caller passes them.
462 c1_buffering = true;
463 }
464 #endif
465 if (!_cb->is_compiled() || c1_buffering) { // compiled frames do not use callee-saved registers
466 bool caller_args = _cb->caller_must_gc_arguments(map->thread()) || c1_buffering;
467 map->set_include_argument_oops(caller_args);
468 if (oop_map() != nullptr) {
469 _oop_map->update_register_map(this, map);
470 }
471 } else {
472 assert(!_cb->caller_must_gc_arguments(map->thread()), "");
473 assert(!map->include_argument_oops(), "");
474 assert(oop_map() == nullptr || !oop_map()->has_any(OopMapValue::callee_saved_value), "callee-saved value in compiled frame");
475 }
476
477 // Since the prolog does the save and restore of FP there is no oopmap
478 // for it so we must fill in its location as if there was an oopmap entry
479 // since if our caller was compiled code there could be live jvm state in it.
480 update_map_with_saved_link(map, saved_fp_addr);
481 }
482
483 if (Continuation::is_return_barrier_entry(sender_pc)) {
484 if (map->walk_cont()) { // about to walk into an h-stack
485 return Continuation::top_frame(*this, map);
486 } else {
487 return Continuation::continuation_bottom_sender(map->thread(), *this, l_sender_sp);
|