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 JVMCIVMStructs;
 43   ContinuationEntryPD _pd;
 44 #ifdef ASSERT
 45  private:
 46   static const int COOKIE_VALUE = 0x1234;
 47   int cookie;
 48 
 49  public:
 50   static int cookie_value() { return COOKIE_VALUE; }
 51   static ByteSize cookie_offset() { return byte_offset_of(ContinuationEntry, cookie); }
 52 
 53   void verify_cookie() {
 54     assert(cookie == COOKIE_VALUE, "Bad cookie: %#x, expected: %#x", cookie, COOKIE_VALUE);
 55   }
 56 #endif
 57 
 58  public:
 59   static int _return_pc_offset; // friend gen_continuation_enter
 60   static int _thaw_call_pc_offset;
 61   static int _cleanup_offset;
 62 
 63   static void set_enter_code(nmethod* nm, int interpreted_entry_offset);
 64   static void set_yield_code(nmethod* nm);
 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 nmethod* _do_yield;
 73   static int _interpreted_entry_offset;
 74 
 75  private:
 76   ContinuationEntry* _parent;
 77   oopDesc* _cont;
 78   oopDesc* _chunk;
 79   int _flags;
 80   // Size in words of the stack arguments of the bottom frame on stack if compiled 0 otherwise.
 81   // The caller (if there is one) is the still frozen top frame in the StackChunk.
 82   int _argsize;
 83   intptr_t* _parent_cont_fastpath;
 84 #ifdef _LP64
 85   int64_t   _parent_held_monitor_count;
 86 #else
 87   int32_t   _parent_held_monitor_count;
 88 #endif
 89   uint32_t _pin_count;
 90 
 91  public:
 92   static ByteSize parent_offset()   { return byte_offset_of(ContinuationEntry, _parent); }
 93   static ByteSize cont_offset()     { return byte_offset_of(ContinuationEntry, _cont); }
 94   static ByteSize chunk_offset()    { return byte_offset_of(ContinuationEntry, _chunk); }
 95   static ByteSize flags_offset()    { return byte_offset_of(ContinuationEntry, _flags); }
 96   static ByteSize argsize_offset()  { return byte_offset_of(ContinuationEntry, _argsize); }
 97   static ByteSize pin_count_offset(){ return byte_offset_of(ContinuationEntry, _pin_count); }
 98   static ByteSize parent_cont_fastpath_offset()      { return byte_offset_of(ContinuationEntry, _parent_cont_fastpath); }
 99   static ByteSize parent_held_monitor_count_offset() { return byte_offset_of(ContinuationEntry, _parent_held_monitor_count); }
100 
101   static address return_pc() { return _return_pc; }
102   static address return_pc_address() { return (address)&_return_pc; }
103 
104  public:
105   static size_t size() { return align_up((int)sizeof(ContinuationEntry), 2*wordSize); }
106 
107   ContinuationEntry* parent() const { return _parent; }
108   int64_t parent_held_monitor_count() const { return (int64_t)_parent_held_monitor_count; }
109 
110   static address entry_pc() { return _return_pc; }
111   intptr_t* entry_sp() const { return (intptr_t*)this; }
112   intptr_t* entry_fp() const;
113 
114   static address thaw_call_pc_address() { return (address)&_thaw_call_pc; }
115   static address cleanup_pc() { return _cleanup_pc; }
116 
117   static address compiled_entry();
118   static address interpreted_entry();
119 
120   static nmethod* do_yield_nmethod() {
121     assert(_do_yield != nullptr, "oops");
122     return _do_yield;
123   }
124 
125   int argsize() const { return _argsize; }
126   void set_argsize(int value) { _argsize = value; }
127 
128   bool is_pinned() { return _pin_count > 0; }
129   bool pin() {
130     if (_pin_count == UINT32_MAX) return false;
131     _pin_count++;
132     return true;
133   }
134   bool unpin() {
135     if (_pin_count == 0) return false;
136     _pin_count--;
137     return true;
138   }
139 
140   intptr_t* parent_cont_fastpath() const { return _parent_cont_fastpath; }
141   void set_parent_cont_fastpath(intptr_t* x) { _parent_cont_fastpath = x; }
142 
143   static ContinuationEntry* from_frame(const frame& f);
144   frame to_frame() const;
145   void update_register_map(RegisterMap* map) const;
146   void flush_stack_processing(JavaThread* thread) const;
147 
148   inline intptr_t* bottom_sender_sp() const;
149   inline oop cont_oop(const JavaThread* thread) const;
150   inline oop scope(const JavaThread* thread) const;
151   inline static oop cont_oop_or_null(const ContinuationEntry* ce, const JavaThread* thread);
152 
153   oop* cont_addr() { return (oop*)&_cont; }
154   oop* chunk_addr() { return (oop*)&_chunk; }
155 
156   bool is_virtual_thread() const { return _flags != 0; }
157 
158 #ifndef PRODUCT
159   void describe(FrameValues& values, int frame_no) const;
160 #endif
161 
162 #ifdef ASSERT
163   static bool assert_entry_frame_laid_out(JavaThread* thread, bool preempted = false);
164 #endif
165 };
166 
167 #endif // SHARE_VM_RUNTIME_CONTINUATIONENTRY_HPP