1 /* 2 * Copyright (c) 2021, 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_OOPS_STACKCHUNKOOP_HPP 26 #define SHARE_OOPS_STACKCHUNKOOP_HPP 27 28 29 #include "oops/instanceOop.hpp" 30 #include "runtime/handles.hpp" 31 #include "runtime/stackChunkFrameStream.hpp" 32 #include "utilities/bitMap.hpp" 33 #include "utilities/macros.hpp" 34 35 class frame; 36 class MemRegion; 37 class RegisterMap; 38 class VMRegImpl; 39 class ObjectMonitor; 40 class ObjectWaiter; 41 typedef VMRegImpl* VMReg; 42 43 // A continuation stack-chunk oop. 44 // See InstanceStackChunkKlass for a description of continuation stack-chunks. 45 // 46 // size and sp are in machine words 47 // max_size is the maximum space a thawed chunk would take up on the stack, *not* including top-most frame's metadata 48 class stackChunkOopDesc : public instanceOopDesc { 49 public: 50 enum class BarrierType { Load, Store }; 51 52 private: 53 template <BarrierType barrier> friend class DoBarriersStackClosure; 54 55 // Chunk flags. 56 // FLAG_HAS_INTERPRETED_FRAMES actually means "thaw slow because of some content-based chunk condition" 57 // It is set whenever we freeze slow, but generally signifies there might be interpreted/deoptimized/stub frames 58 static const uint8_t FLAG_HAS_INTERPRETED_FRAMES = 1 << 0; 59 static const uint8_t FLAG_CLAIM_RELATIVIZE = 1 << 1; // Only one thread claims relativization of derived pointers 60 static const uint8_t FLAG_NOTIFY_RELATIVIZE = 1 << 2; // Someone is waiting for relativization to complete 61 static const uint8_t FLAG_GC_MODE = 1 << 3; // Once true it and FLAG_HAS_INTERPRETED_FRAMES can't change 62 static const uint8_t FLAG_HAS_BITMAP = 1 << 4; // Can only be true if FLAG_GC_MODE is true 63 static const uint8_t FLAG_HAS_LOCKSTACK = 1 << 5; // LockStack was copied into stackChunk 64 static const uint8_t FLAG_PREEMPTED_MONITORENTER = 1 << 6; // Continuation was preempted on monitorenter 65 static const uint8_t FLAG_PREEMPTED_WAIT = 1 << 7; // Continuation was preempted on Object.wait() 66 67 static const uint8_t FLAGS_PREEMPTED = FLAG_PREEMPTED_MONITORENTER | FLAG_PREEMPTED_WAIT; 68 static const int preempt_shift = 6; 69 70 bool try_acquire_relativization(); 71 void release_relativization(); 72 73 public: 74 static inline stackChunkOop cast(oop obj); 75 76 inline stackChunkOop parent() const; 77 inline void set_parent(stackChunkOop value); 78 template<typename P> 79 inline void set_parent_raw(oop value); 80 template<DecoratorSet decorators> 81 inline void set_parent_access(oop value); 82 83 inline int stack_size() const; 84 85 inline int sp() const; 86 inline void set_sp(int value); 87 88 inline address pc() const; 89 inline void set_pc(address value); 90 91 inline int argsize() const; 92 inline void set_argsize(int value); 93 94 inline uint8_t flags() const; 95 inline uint8_t flags_acquire() const; 96 inline void set_flags(uint8_t value); 97 inline void release_set_flags(uint8_t value); 98 99 inline int max_thawing_size() const; 100 inline void set_max_thawing_size(int value); 101 102 inline uint8_t lockstack_size() const; 103 inline void set_lockstack_size(uint8_t value); 104 105 inline ObjectWaiter* object_waiter() const; 106 inline void set_object_waiter(ObjectWaiter* obj_waiter); 107 108 inline ObjectMonitor* current_pending_monitor() const; 109 inline ObjectMonitor* current_waiting_monitor() const; 110 111 inline oop cont() const; 112 template<typename P> 113 inline oop cont() const; 114 inline void set_cont(oop value); 115 template<typename P> 116 inline void set_cont_raw(oop value); 117 template<DecoratorSet decorators> 118 inline void set_cont_access(oop value); 119 120 inline int bottom() const; 121 inline void set_bottom(int value); 122 123 inline HeapWord* start_of_stack() const; 124 125 inline intptr_t* start_address() const; 126 inline intptr_t* end_address() const; 127 inline intptr_t* bottom_address() const; // = end_address - argsize 128 inline intptr_t* sp_address() const; 129 130 131 inline int to_offset(intptr_t* p) const; 132 inline intptr_t* from_offset(int offset) const; 133 134 inline bool is_empty() const; 135 inline bool is_in_chunk(void* p) const; 136 inline bool is_usable_in_chunk(void* p) const; 137 138 inline bool is_flag(uint8_t flag) const; 139 inline bool is_flag_acquire(uint8_t flag) const; 140 inline void set_flag(uint8_t flag, bool value); 141 inline bool try_set_flags(uint8_t prev_flags, uint8_t new_flags); 142 inline void clear_flags(uint8_t flag); 143 inline void clear_flags(); 144 145 inline bool has_mixed_frames() const; 146 inline void set_has_mixed_frames(bool value); 147 148 inline void set_preempt_kind(int freeze_kind); 149 inline int get_and_clear_preempt_kind(); 150 151 inline bool has_lockstack() const; 152 inline void set_has_lockstack(bool value); 153 154 inline bool is_gc_mode() const; 155 inline bool is_gc_mode_acquire() const; 156 inline void set_gc_mode(bool value); 157 158 inline bool has_bitmap() const; 159 inline void set_has_bitmap(bool value); 160 161 inline bool has_thaw_slowpath_condition() const; 162 163 inline bool requires_barriers(); 164 165 template <BarrierType> 166 void do_barriers(); 167 168 template <BarrierType, ChunkFrames frames, typename RegisterMapT> 169 inline void do_barriers(const StackChunkFrameStream<frames>& f, const RegisterMapT* map); 170 171 template <typename RegisterMapT> 172 void fix_thawed_frame(const frame& f, const RegisterMapT* map); 173 174 void copy_lockstack(oop* start); 175 176 template <typename OopT, class StackChunkLockStackClosureType> 177 inline void iterate_lockstack(StackChunkLockStackClosureType* closure); 178 179 template <class StackChunkFrameClosureType> 180 inline void iterate_stack(StackChunkFrameClosureType* closure); 181 182 // Derived pointers are relativized, with respect to their oop base. 183 void relativize_derived_pointers_concurrently(); 184 void transform(); 185 186 inline void* gc_data() const; 187 inline BitMapView bitmap() const; 188 inline BitMap::idx_t bit_index_for(address p) const; 189 inline intptr_t* address_for_bit(BitMap::idx_t index) const; 190 template <typename OopT> inline BitMap::idx_t bit_index_for(OopT* p) const; 191 template <typename OopT> inline OopT* address_for_bit(BitMap::idx_t index) const; 192 193 MemRegion range(); 194 195 // Returns a relative frame (with offset_sp, offset_unextended_sp, and offset_fp) that can be held 196 // during safepoints. This is orthogonal to the relativizing of the actual content of interpreted frames. 197 // To be used, frame objects need to be derelativized with `derelativize`. 198 inline frame relativize(frame fr) const; 199 inline frame derelativize(frame fr) const; 200 201 frame top_frame(RegisterMap* map); 202 frame sender(const frame& fr, RegisterMap* map); 203 204 inline int relativize_usp_offset(const frame& fr, const int usp_offset_in_bytes) const; 205 inline address usp_offset_to_location(const frame& fr, const int usp_offset_in_bytes) const; 206 inline address reg_to_location(const frame& fr, const RegisterMap* map, VMReg reg) const; 207 208 // Access to relativized interpreter frames (both the frame object and frame content are relativized) 209 inline Method* interpreter_frame_method(const frame& fr); 210 inline address interpreter_frame_bcp(const frame& fr); 211 inline intptr_t* interpreter_frame_expression_stack_at(const frame& fr, int index) const; 212 inline intptr_t* interpreter_frame_local_at(const frame& fr, int index) const; 213 214 int num_java_frames() const; 215 216 inline void copy_from_stack_to_chunk(intptr_t* from, intptr_t* to, int size); 217 inline void copy_from_chunk_to_stack(intptr_t* from, intptr_t* to, int size); 218 219 template <typename OopT> 220 inline oop load_oop(OopT* addr); 221 222 using oopDesc::print_on; 223 void print_on(bool verbose, outputStream* st) const; 224 225 // Verifies the consistency of the chunk's data 226 bool verify(size_t* out_size = nullptr, int* out_oops = nullptr, 227 int* out_frames = nullptr, int* out_interpreted_frames = nullptr) NOT_DEBUG({ return true; }); 228 229 private: 230 template <BarrierType barrier, ChunkFrames frames = ChunkFrames::Mixed, typename RegisterMapT> 231 void do_barriers0(const StackChunkFrameStream<frames>& f, const RegisterMapT* map); 232 233 template <ChunkFrames frames, class StackChunkFrameClosureType> 234 inline void iterate_stack(StackChunkFrameClosureType* closure); 235 236 inline intptr_t* relative_base() const; 237 238 inline intptr_t* derelativize_address(int offset) const; 239 int relativize_address(intptr_t* p) const; 240 241 inline void relativize_frame(frame& fr) const; 242 inline void derelativize_frame(frame& fr) const; 243 244 inline void relativize_frame_pd(frame& fr) const; 245 inline void derelativize_frame_pd(frame& fr) const; 246 }; 247 248 #endif // SHARE_OOPS_STACKCHUNKOOP_HPP