38 #include "runtime/frame.inline.hpp"
39 #include "utilities/debug.hpp"
40 #include "utilities/devirtualizer.inline.hpp"
41 #include "utilities/globalDefinitions.hpp"
42 #include "utilities/macros.hpp"
43 #include CPU_HEADER_INLINE(stackChunkFrameStream)
44
45 #ifdef ASSERT
46 extern "C" bool dbg_is_safe(const void* p, intptr_t errvalue);
47 #endif
48
49 template <ChunkFrames frame_kind>
50 StackChunkFrameStream<frame_kind>::StackChunkFrameStream(stackChunkOop chunk) DEBUG_ONLY(: _chunk(chunk)) {
51 assert(chunk->is_stackChunk_noinline(), "");
52 assert(frame_kind == ChunkFrames::Mixed || !chunk->has_mixed_frames(), "");
53
54 DEBUG_ONLY(_index = 0;)
55 _end = chunk->bottom_address();
56 _sp = chunk->start_address() + chunk->sp();
57 assert(_sp <= chunk->end_address() + frame::metadata_words, "");
58
59 get_cb();
60
61 if (frame_kind == ChunkFrames::Mixed) {
62 _unextended_sp = (!is_done() && is_interpreted()) ? unextended_sp_for_interpreter_frame() : _sp;
63 assert(_unextended_sp >= _sp - frame::metadata_words, "");
64 }
65 DEBUG_ONLY(else _unextended_sp = nullptr;)
66
67 if (is_stub()) {
68 get_oopmap(pc(), 0);
69 DEBUG_ONLY(_has_stub = true);
70 } DEBUG_ONLY(else _has_stub = false;)
71 }
72
73 template <ChunkFrames frame_kind>
74 StackChunkFrameStream<frame_kind>::StackChunkFrameStream(stackChunkOop chunk, const frame& f)
75 DEBUG_ONLY(: _chunk(chunk)) {
76 assert(chunk->is_stackChunk_noinline(), "");
77 assert(frame_kind == ChunkFrames::Mixed || !chunk->has_mixed_frames(), "");
78 // assert(!is_empty(), ""); -- allowed to be empty
79
80 DEBUG_ONLY(_index = 0;)
81
82 _end = chunk->bottom_address();
83
84 assert(chunk->is_in_chunk(f.sp()), "");
85 _sp = f.sp();
86 if (frame_kind == ChunkFrames::Mixed) {
87 _unextended_sp = f.unextended_sp();
88 assert(_unextended_sp >= _sp - frame::metadata_words, "");
89 }
90 DEBUG_ONLY(else _unextended_sp = nullptr;)
91 assert(_sp >= chunk->start_address(), "");
92 assert(_sp <= chunk->end_address() + frame::metadata_words, "");
93
94 if (f.cb() != nullptr) {
95 _oopmap = nullptr;
96 _cb = f.cb();
97 } else {
98 get_cb();
99 }
100
101 if (is_stub()) {
102 get_oopmap(pc(), 0);
103 DEBUG_ONLY(_has_stub = true);
104 } DEBUG_ONLY(else _has_stub = false;)
105 }
106
107 template <ChunkFrames frame_kind>
108 inline bool StackChunkFrameStream<frame_kind>::is_stub() const {
109 return cb() != nullptr && _cb->is_runtime_stub();
110 }
111
112 template <ChunkFrames frame_kind>
200 if (is_interpreted()) {
201 return interpreter_frame_num_oops(map);
202 } else if (is_compiled()) {
203 return oopmap()->num_oops();
204 } else {
205 assert(is_stub(), "invariant");
206 return 0;
207 }
208 }
209
210 template <ChunkFrames frame_kind>
211 inline void StackChunkFrameStream<frame_kind>::initialize_register_map(RegisterMap* map) {
212 update_reg_map_pd(map);
213 }
214
215 template <ChunkFrames frame_kind>
216 template <typename RegisterMapT>
217 inline void StackChunkFrameStream<frame_kind>::next(RegisterMapT* map, bool stop) {
218 update_reg_map(map);
219 bool is_runtime_stub = is_stub();
220 if (frame_kind == ChunkFrames::Mixed) {
221 if (is_interpreted()) {
222 next_for_interpreter_frame();
223 } else {
224 _sp = _unextended_sp + cb()->frame_size();
225 if (_sp >= _end - frame::metadata_words) {
226 _sp = _end;
227 }
228 _unextended_sp = is_interpreted() ? unextended_sp_for_interpreter_frame() : _sp;
229 }
230 assert(_unextended_sp >= _sp - frame::metadata_words, "");
231 } else {
232 _sp += cb()->frame_size();
233 }
234 assert(!is_interpreted() || _unextended_sp == unextended_sp_for_interpreter_frame(), "");
235
236 DEBUG_ONLY(_index++;)
237 if (stop) {
238 return;
239 }
240
241 get_cb();
242 update_reg_map_pd(map);
243 if (is_runtime_stub && cb() != nullptr) { // there's no post-call nop and no fast oopmap lookup
244 // caller could have been deoptimized so use orig_pc()
245 _oopmap = cb()->oop_map_for_return_address(orig_pc());
246 }
247 }
248
249 template <ChunkFrames frame_kind>
250 inline void StackChunkFrameStream<frame_kind>::get_cb() {
251 _oopmap = nullptr;
252 if (is_done() || is_interpreted()) {
|
38 #include "runtime/frame.inline.hpp"
39 #include "utilities/debug.hpp"
40 #include "utilities/devirtualizer.inline.hpp"
41 #include "utilities/globalDefinitions.hpp"
42 #include "utilities/macros.hpp"
43 #include CPU_HEADER_INLINE(stackChunkFrameStream)
44
45 #ifdef ASSERT
46 extern "C" bool dbg_is_safe(const void* p, intptr_t errvalue);
47 #endif
48
49 template <ChunkFrames frame_kind>
50 StackChunkFrameStream<frame_kind>::StackChunkFrameStream(stackChunkOop chunk) DEBUG_ONLY(: _chunk(chunk)) {
51 assert(chunk->is_stackChunk_noinline(), "");
52 assert(frame_kind == ChunkFrames::Mixed || !chunk->has_mixed_frames(), "");
53
54 DEBUG_ONLY(_index = 0;)
55 _end = chunk->bottom_address();
56 _sp = chunk->start_address() + chunk->sp();
57 assert(_sp <= chunk->end_address() + frame::metadata_words, "");
58 _callee_augmented = false;
59
60 get_cb();
61
62 if (frame_kind == ChunkFrames::Mixed) {
63 _unextended_sp = (!is_done() && is_interpreted()) ? unextended_sp_for_interpreter_frame() : _sp;
64 assert(_unextended_sp >= _sp - frame::metadata_words, "");
65 } else {
66 _unextended_sp = _sp;
67 }
68
69 if (is_stub()) {
70 get_oopmap(pc(), 0);
71 DEBUG_ONLY(_has_stub = true);
72 } DEBUG_ONLY(else _has_stub = false;)
73 }
74
75 template <ChunkFrames frame_kind>
76 StackChunkFrameStream<frame_kind>::StackChunkFrameStream(stackChunkOop chunk, const frame& f)
77 DEBUG_ONLY(: _chunk(chunk)) {
78 assert(chunk->is_stackChunk_noinline(), "");
79 assert(frame_kind == ChunkFrames::Mixed || !chunk->has_mixed_frames(), "");
80 // assert(!is_empty(), ""); -- allowed to be empty
81
82 DEBUG_ONLY(_index = 0;)
83
84 _end = chunk->bottom_address();
85
86 assert(chunk->is_in_chunk(f.sp()), "");
87 _sp = f.sp();
88 if (frame_kind == ChunkFrames::Mixed) {
89 _unextended_sp = f.unextended_sp();
90 assert(_unextended_sp >= _sp - frame::metadata_words, "");
91 } else {
92 _unextended_sp = _sp;
93 }
94 assert(_sp >= chunk->start_address(), "");
95 assert(_sp <= chunk->end_address() + frame::metadata_words, "");
96 _callee_augmented = false;
97
98 if (f.cb() != nullptr) {
99 _oopmap = nullptr;
100 _cb = f.cb();
101 } else {
102 get_cb();
103 }
104
105 if (is_stub()) {
106 get_oopmap(pc(), 0);
107 DEBUG_ONLY(_has_stub = true);
108 } DEBUG_ONLY(else _has_stub = false;)
109 }
110
111 template <ChunkFrames frame_kind>
112 inline bool StackChunkFrameStream<frame_kind>::is_stub() const {
113 return cb() != nullptr && _cb->is_runtime_stub();
114 }
115
116 template <ChunkFrames frame_kind>
204 if (is_interpreted()) {
205 return interpreter_frame_num_oops(map);
206 } else if (is_compiled()) {
207 return oopmap()->num_oops();
208 } else {
209 assert(is_stub(), "invariant");
210 return 0;
211 }
212 }
213
214 template <ChunkFrames frame_kind>
215 inline void StackChunkFrameStream<frame_kind>::initialize_register_map(RegisterMap* map) {
216 update_reg_map_pd(map);
217 }
218
219 template <ChunkFrames frame_kind>
220 template <typename RegisterMapT>
221 inline void StackChunkFrameStream<frame_kind>::next(RegisterMapT* map, bool stop) {
222 update_reg_map(map);
223 bool is_runtime_stub = is_stub();
224 _callee_augmented = false;
225 if (frame_kind == ChunkFrames::Mixed) {
226 if (is_interpreted()) {
227 next_for_interpreter_frame();
228 } else {
229 _sp = _unextended_sp + cb()->frame_size();
230 if (_sp >= _end - frame::metadata_words) {
231 _sp = _end;
232 }
233 if (is_interpreted()) {
234 _unextended_sp = unextended_sp_for_interpreter_frame();
235 #ifndef ZERO
236 } else if (cb()->is_nmethod() && cb()->as_nmethod()->needs_stack_repair()) {
237 _unextended_sp = frame::repair_sender_sp(cb()->as_nmethod(), _unextended_sp, (intptr_t**)(_sp - frame::sender_sp_offset));
238 _callee_augmented = _unextended_sp != _sp;
239 #endif
240 } else {
241 _unextended_sp = _sp;
242 }
243 }
244 assert(_unextended_sp >= _sp - frame::metadata_words, "");
245 } else {
246 _sp = _unextended_sp + cb()->frame_size();
247 #ifndef ZERO
248 if (cb()->is_nmethod() && cb()->as_nmethod()->needs_stack_repair()) {
249 _unextended_sp = frame::repair_sender_sp(cb()->as_nmethod(), _unextended_sp, (intptr_t**)(_sp - frame::sender_sp_offset));
250 _callee_augmented = _unextended_sp != _sp;
251 } else
252 #endif
253 {
254 _unextended_sp = _sp;
255 }
256 }
257 assert(!is_interpreted() || _unextended_sp == unextended_sp_for_interpreter_frame(), "");
258
259 DEBUG_ONLY(_index++;)
260 if (stop) {
261 return;
262 }
263
264 get_cb();
265 update_reg_map_pd(map);
266 if (is_runtime_stub && cb() != nullptr) { // there's no post-call nop and no fast oopmap lookup
267 // caller could have been deoptimized so use orig_pc()
268 _oopmap = cb()->oop_map_for_return_address(orig_pc());
269 }
270 }
271
272 template <ChunkFrames frame_kind>
273 inline void StackChunkFrameStream<frame_kind>::get_cb() {
274 _oopmap = nullptr;
275 if (is_done() || is_interpreted()) {
|