1 /*
2 * Copyright (c) 2022, 2025, 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_CONTINUATIONENTRY_HPP
26 #define SHARE_VM_RUNTIME_CONTINUATIONENTRY_HPP
27
28 #include "oops/oop.hpp"
29 #include "oops/oopsHierarchy.hpp"
30 #include "runtime/continuation.hpp"
31 #include "utilities/sizes.hpp"
32
33 #include CPU_HEADER(continuationEntry)
34
35 class JavaThread;
36 class nmethod;
37 class OopMap;
38 class RegisterMap;
39
40 // Metadata stored in the continuation entry frame
41 class ContinuationEntry {
42 friend class VMStructs;
43 friend class JVMCIVMStructs;
44 ContinuationEntryPD _pd;
45 #ifdef ASSERT
46 private:
47 static const int COOKIE_VALUE = 0x1234;
48 int cookie;
49
50 public:
51 static int cookie_value() { return COOKIE_VALUE; }
52 static ByteSize cookie_offset() { return byte_offset_of(ContinuationEntry, cookie); }
53
54 void verify_cookie() {
55 assert(cookie == COOKIE_VALUE, "Bad cookie: %#x, expected: %#x", cookie, COOKIE_VALUE);
56 }
57 #endif
58
59 public:
60 static int _return_pc_offset; // friend gen_continuation_enter
61 static int _thaw_call_pc_offset;
62 static int _cleanup_offset;
63
64 static void set_enter_code(nmethod* nm, int interpreted_entry_offset);
65 static bool is_interpreted_call(address call_address);
66
67 private:
68 static address _return_pc;
69 static address _thaw_call_pc;
70 static address _cleanup_pc;
71 static nmethod* _enter_special;
72 static int _interpreted_entry_offset;
73
74 private:
75 ContinuationEntry* _parent;
76 oopDesc* _cont;
77 oopDesc* _chunk;
78 int _flags;
79 // Size in words of the stack arguments of the bottom frame on stack if compiled 0 otherwise.
80 // The caller (if there is one) is the still frozen top frame in the StackChunk.
81 int _argsize;
82 intptr_t* _parent_cont_fastpath;
83 uint32_t _pin_count;
84
85 public:
86 static ByteSize parent_offset() { return byte_offset_of(ContinuationEntry, _parent); }
87 static ByteSize cont_offset() { return byte_offset_of(ContinuationEntry, _cont); }
88 static ByteSize chunk_offset() { return byte_offset_of(ContinuationEntry, _chunk); }
89 static ByteSize flags_offset() { return byte_offset_of(ContinuationEntry, _flags); }
90 static ByteSize argsize_offset() { return byte_offset_of(ContinuationEntry, _argsize); }
91 static ByteSize pin_count_offset(){ return byte_offset_of(ContinuationEntry, _pin_count); }
92 static ByteSize parent_cont_fastpath_offset() { return byte_offset_of(ContinuationEntry, _parent_cont_fastpath); }
93
94 static address return_pc() { return _return_pc; }
95 static address return_pc_address() { return (address)&_return_pc; }
96
97 public:
98 static size_t size() { return align_up((int)sizeof(ContinuationEntry), 2*wordSize); }
99
100 ContinuationEntry* parent() const { return _parent; }
101
102 static address entry_pc() { return _return_pc; }
103 intptr_t* entry_sp() const { return (intptr_t*)this; }
104 intptr_t* entry_fp() const;
105
106 static address thaw_call_pc_address() { return (address)&_thaw_call_pc; }
107 static address cleanup_pc() { return _cleanup_pc; }
108
109 static address compiled_entry();
110 static address interpreted_entry();
111
112 int argsize() const { return _argsize; }
113 void set_argsize(int value) { _argsize = value; }
114
115 bool is_pinned() { return _pin_count > 0; }
116 bool pin() {
117 if (_pin_count == UINT32_MAX) return false;
118 _pin_count++;
119 return true;
120 }
121 bool unpin() {
122 if (_pin_count == 0) return false;
123 _pin_count--;
124 return true;
125 }
126
127 intptr_t* parent_cont_fastpath() const { return _parent_cont_fastpath; }
128 void set_parent_cont_fastpath(intptr_t* x) { _parent_cont_fastpath = x; }
129
130 static ContinuationEntry* from_frame(const frame& f);
131 frame to_frame() const;
132 void update_register_map(RegisterMap* map) const;
133 void flush_stack_processing(JavaThread* thread) const;
134
135 inline intptr_t* bottom_sender_sp() const;
136 inline oop cont_oop(const JavaThread* thread) const;
137 inline oop scope(const JavaThread* thread) const;
138 inline static oop cont_oop_or_null(const ContinuationEntry* ce, const JavaThread* thread);
139
140 oop* cont_addr() { return (oop*)&_cont; }
141 oop* chunk_addr() { return (oop*)&_chunk; }
142
143 bool is_virtual_thread() const { return _flags != 0; }
144
145 #ifndef PRODUCT
146 void describe(FrameValues& values, int frame_no) const;
147 #endif
148
149 #ifdef ASSERT
150 static bool assert_entry_frame_laid_out(JavaThread* thread, bool preempted = false);
151 #endif
152 };
153
154 #endif // SHARE_VM_RUNTIME_CONTINUATIONENTRY_HPP