1 /*
2 * Copyright (c) 2022, 2023, 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 SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP
26 #define SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP
27
28 #include "code/scopeDesc.hpp"
29 #include "compiler/oopMap.hpp"
30 #include "memory/allStatic.hpp"
31 #include "runtime/frame.hpp"
32 #include "runtime/stackValue.hpp"
33
34 // Helper, all-static
35 class ContinuationEntry;
36
37 class ContinuationHelper {
38 public:
39 static inline void set_anchor_pd(JavaFrameAnchor* anchor, intptr_t* sp);
40 static inline void set_anchor_to_entry_pd(JavaFrameAnchor* anchor, ContinuationEntry* entry);
41
42 template<typename FKind> static void update_register_map(const frame& f, RegisterMap* map);
43 static inline void update_register_map_with_callee(const frame& f, RegisterMap* map);
44
45 static inline void push_pd(const frame& f);
46
47 static inline address return_address_at(intptr_t* sp);
48 static inline void patch_return_address_at(intptr_t* sp, address pc);
49
50 static inline int frame_align_words(int size);
51 static inline intptr_t* frame_align_pointer(intptr_t* sp);
52
53 // Abstract helpers for describing frames in general
54 class Frame;
55 class NonInterpretedFrame;
56
57 // Concrete helpers for describing concrete types of frames
58 class InterpretedFrame;
59 class NonInterpretedUnknownFrame;
60 class CompiledFrame;
61 class NativeFrame;
62 class StubFrame;
63 };
64
65 class ContinuationHelper::Frame : public AllStatic {
66 public:
67 static const bool interpreted = false;
68 static const bool stub = false;
69
70 static inline intptr_t** callee_link_address(const frame& f);
71 static Method* frame_method(const frame& f);
72 static inline address real_pc(const frame& f);
73 static inline void patch_pc(const frame& f, address pc);
74 static address* return_pc_address(const frame& f);
75 static address return_pc(const frame& f);
76 static bool is_stub(CodeBlob* cb);
77
78 #ifdef ASSERT
79 static inline intptr_t* frame_top(const frame &f);
80 static inline bool is_deopt_return(address pc, const frame& sender);
81 static bool assert_frame_laid_out(frame f);
82 #endif
83 };
84
85 class ContinuationHelper::InterpretedFrame : public ContinuationHelper::Frame {
86 public:
87 static const bool interpreted = true;
88
89 static inline intptr_t* frame_top(const frame& f, InterpreterOopMap* mask);
90 static inline intptr_t* frame_top(const frame& f);
91 static inline intptr_t* frame_top(const frame& f, int callee_argsize, bool callee_interpreted);
92 static inline intptr_t* frame_bottom(const frame& f);
93 static inline intptr_t* callers_sp(const frame& f);
94 static inline int stack_argsize(const frame& f);
95
96 static inline address* return_pc_address(const frame& f);
97 static address return_pc(const frame& f);
98 static void patch_sender_sp(frame& f, const frame& caller);
99
100 static int size(const frame& f);
101 static inline int expression_stack_size(const frame &f, InterpreterOopMap* mask);
102
103 static int monitors_to_fix(JavaThread* thread, const frame& f, ResourceHashtable<oopDesc*, bool> &table, stackChunkOop chunk) NOT_DEBUG_RETURN0;
104
105 static bool is_instance(const frame& f);
106
107 typedef InterpreterOopMap* ExtraT;
108 };
109
110 class ContinuationHelper::NonInterpretedFrame : public ContinuationHelper::Frame {
111 public:
112 static inline intptr_t* frame_top(const frame& f, int callee_argsize, bool callee_interpreted);
113 static inline intptr_t* frame_top(const frame& f);
114 static inline intptr_t* frame_bottom(const frame& f);
115
116 static inline int size(const frame& f);
117 static inline int stack_argsize(const frame& f);
118 };
119
120 class ContinuationHelper::NonInterpretedUnknownFrame : public ContinuationHelper::NonInterpretedFrame {
121 public:
122 static bool is_instance(const frame& f);
123 };
124
125 class ContinuationHelper::CompiledFrame : public ContinuationHelper::NonInterpretedFrame {
126 public:
127 static bool is_instance(const frame& f);
128
129 template <typename RegisterMapT>
130 static int monitors_to_fix(JavaThread* thread, RegisterMapT* map, const frame& f, ResourceHashtable<oopDesc*, bool> &table) NOT_DEBUG_RETURN0;
131 };
132
133 class ContinuationHelper::NativeFrame : public ContinuationHelper::NonInterpretedFrame {
134 public:
135 static bool is_instance(const frame& f);
136
137 static int monitors_to_fix(JavaThread* thread, const frame& f, ResourceHashtable<oopDesc*, bool> &table) NOT_DEBUG_RETURN0;
138 };
139
140 class ContinuationHelper::StubFrame : public ContinuationHelper::NonInterpretedFrame {
141 public:
142 static const bool stub = true;
143
144 static bool is_instance(const frame& f);
145 static int stack_argsize(const frame& f) { return 0; }
146 };
147
148 #endif // SHARE_VM_RUNTIME_CONTINUATIONHELPER_HPP