1 /*
2 * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef CPU_AARCH64_STACKCHUNKFRAMESTREAM_AARCH64_INLINE_HPP
26 #define CPU_AARCH64_STACKCHUNKFRAMESTREAM_AARCH64_INLINE_HPP
27
28 #include "interpreter/oopMapCache.hpp"
29 #include "pauth_aarch64.hpp"
30 #include "runtime/frame.inline.hpp"
31 #include "runtime/registerMap.hpp"
32
33 #ifdef ASSERT
34 template <ChunkFrames frame_kind>
35 inline bool StackChunkFrameStream<frame_kind>::is_in_frame(void* p0) const {
36 assert(!is_done(), "");
37 intptr_t* p = (intptr_t*)p0;
38 int argsize = is_compiled() ? (_cb->as_nmethod()->num_stack_arg_slots() * VMRegImpl::stack_slot_size) >> LogBytesPerWord : 0;
39 int frame_size = _cb->frame_size() + argsize;
40 return p == sp() - frame::sender_sp_offset || ((p - unextended_sp()) >= 0 && (p - unextended_sp()) < frame_size);
41 }
42 #endif
43
44 template <ChunkFrames frame_kind>
45 inline frame StackChunkFrameStream<frame_kind>::to_frame() const {
46 if (is_done()) {
47 return frame(_sp, _sp, nullptr, nullptr, nullptr, nullptr, true);
48 } else {
49 return frame(sp(), unextended_sp(), fp(), pc(), cb(), _oopmap, true);
50 }
51 }
52
53 template <ChunkFrames frame_kind>
54 inline address StackChunkFrameStream<frame_kind>::get_pc() const {
55 assert(!is_done(), "");
56 // Just strip it for frames on the heap.
57 return pauth_strip_pointer(*(address*)(_sp - 1));
58 }
59
60 template <ChunkFrames frame_kind>
61 inline intptr_t* StackChunkFrameStream<frame_kind>::fp() const {
62 intptr_t* fp_addr = _sp - frame::sender_sp_offset;
63 return (frame_kind == ChunkFrames::Mixed && is_interpreted())
64 ? fp_addr + *fp_addr // derelativize
65 : *(intptr_t**)fp_addr;
66 }
67
68 template <ChunkFrames frame_kind>
69 inline intptr_t* StackChunkFrameStream<frame_kind>::derelativize(int offset) const {
70 intptr_t* fp = this->fp();
71 assert(fp != nullptr, "");
72 return fp + fp[offset];
73 }
74
75 template <ChunkFrames frame_kind>
76 inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interpreter_frame() const {
77 assert_is_interpreted_and_frame_type_mixed();
78 return derelativize(frame::interpreter_frame_last_sp_offset);
79 }
80
81 template <ChunkFrames frame_kind>
82 inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
83 assert_is_interpreted_and_frame_type_mixed();
84 if (derelativize(frame::interpreter_frame_locals_offset) + 1 >= _end) {
85 _unextended_sp = _end;
86 _sp = _end;
87 } else {
88 intptr_t* fp = this->fp();
89 _unextended_sp = fp + fp[frame::interpreter_frame_sender_sp_offset];
90 _sp = fp + frame::sender_sp_offset;
91 }
92 }
93
94 template <ChunkFrames frame_kind>
95 inline int StackChunkFrameStream<frame_kind>::interpreter_frame_size() const {
96 assert_is_interpreted_and_frame_type_mixed();
97
98 intptr_t* top = unextended_sp(); // later subtract argsize if callee is interpreted
99 intptr_t* bottom = derelativize(frame::interpreter_frame_locals_offset) + 1; // the sender's unextended sp: derelativize(frame::interpreter_frame_sender_sp_offset);
100 return (int)(bottom - top);
101 }
102
103 template <ChunkFrames frame_kind>
104 inline int StackChunkFrameStream<frame_kind>::interpreter_frame_stack_argsize() const {
105 assert_is_interpreted_and_frame_type_mixed();
106 int diff = (int)(derelativize(frame::interpreter_frame_locals_offset) - derelativize(frame::interpreter_frame_sender_sp_offset) + 1);
107 return diff;
108 }
109
110 class InterpreterOopCount : public OopClosure {
111 int _count;
112 public:
113 InterpreterOopCount() : _count(0) {}
114 void do_oop(oop* p) override { _count++; }
115 void do_oop(narrowOop* p) override { _count++; }
116 int count() { return _count; }
117 };
118
119 template <ChunkFrames frame_kind>
120 template <typename RegisterMapT>
121 inline int StackChunkFrameStream<frame_kind>::interpreter_frame_num_oops(RegisterMapT* map) const {
122 assert_is_interpreted_and_frame_type_mixed();
123 ResourceMark rm;
124 frame f = to_frame();
125 InterpreterOopCount closure;
126 f.oops_interpreted_do(&closure, map, false);
127 return closure.count();
128 }
129
130 template<>
131 template<>
132 inline void StackChunkFrameStream<ChunkFrames::Mixed>::update_reg_map_pd(RegisterMap* map) {
133 if (map->update_map()) {
134 frame::update_map_with_saved_link(map, map->in_cont() ? (intptr_t**)(intptr_t)frame::sender_sp_offset
135 : (intptr_t**)(_sp - frame::sender_sp_offset));
136 }
137 }
138
139 template<>
140 template<>
141 inline void StackChunkFrameStream<ChunkFrames::CompiledOnly>::update_reg_map_pd(RegisterMap* map) {
142 if (map->update_map()) {
143 frame::update_map_with_saved_link(map, map->in_cont() ? (intptr_t**)(intptr_t)frame::sender_sp_offset
144 : (intptr_t**)(_sp - frame::sender_sp_offset));
145 }
146 }
147
148 template <ChunkFrames frame_kind>
149 template <typename RegisterMapT>
150 inline void StackChunkFrameStream<frame_kind>::update_reg_map_pd(RegisterMapT* map) {}
151
152 #endif // CPU_AARCH64_STACKCHUNKFRAMESTREAM_AARCH64_INLINE_HPP