< prev index next >

src/hotspot/share/oops/stackChunkOop.hpp

Print this page

  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 typedef VMRegImpl* VMReg;
 40 
 41 // A continuation stack-chunk oop.
 42 // See InstanceStackChunkKlass for a description of continuation stack-chunks.
 43 //
 44 // size and sp are in machine words
 45 // max_size is the maximum space a thawed chunk would take up on the stack, *not* including top-most frame's metadata
 46 class stackChunkOopDesc : public instanceOopDesc {
 47 public:
 48   enum class BarrierType { Load, Store };
 49 
 50 private:
 51   template <BarrierType barrier> friend class DoBarriersStackClosure;
 52 
 53   // Chunk flags.
 54   // FLAG_HAS_INTERPRETED_FRAMES actually means "thaw slow because of some content-based chunk condition"
 55   // It is set whenever we freeze slow, but generally signifies there might be interpreted/deoptimized/stub frames
 56   static const uint8_t FLAG_HAS_INTERPRETED_FRAMES = 1 << 0;
 57   static const uint8_t FLAG_CLAIM_RELATIVIZE = 1 << 1; // Only one thread claims relativization of derived pointers
 58   static const uint8_t FLAG_NOTIFY_RELATIVIZE = 1 << 2; // Someone is waiting for relativization to complete
 59   static const uint8_t FLAG_GC_MODE = 1 << 3; // Once true it and FLAG_HAS_INTERPRETED_FRAMES can't change
 60   static const uint8_t FLAG_HAS_BITMAP = 1 << 4; // Can only be true if FLAG_GC_MODE is true


 61 
 62   bool try_acquire_relativization();
 63   void release_relativization();
 64 
 65 public:
 66   static inline stackChunkOop cast(oop obj);
 67 
 68   inline stackChunkOop parent() const;
 69   inline void set_parent(stackChunkOop value);
 70   template<typename P>
 71   inline void set_parent_raw(oop value);
 72   template<DecoratorSet decorators>
 73   inline void set_parent_access(oop value);
 74 
 75   inline int stack_size() const;
 76 
 77   inline int sp() const;
 78   inline void set_sp(int value);
 79 
 80   inline address pc() const;
 81   inline void set_pc(address value);
 82 
 83   inline int argsize() const;
 84   inline void set_argsize(int value);
 85 
 86   inline uint8_t flags() const;
 87   inline uint8_t flags_acquire() const;
 88   inline void set_flags(uint8_t value);
 89   inline void release_set_flags(uint8_t value);
 90 
 91   inline int max_thawing_size() const;
 92   inline void set_max_thawing_size(int value);
 93 









 94   inline oop cont() const;
 95   template<typename P>
 96   inline oop cont() const;
 97   inline void set_cont(oop value);
 98   template<typename P>
 99   inline void set_cont_raw(oop value);
100   template<DecoratorSet decorators>
101   inline void set_cont_access(oop value);
102 
103   inline int bottom() const;
104   inline void set_bottom(int value);
105 
106   inline HeapWord* start_of_stack() const;
107 
108   inline intptr_t* start_address() const;
109   inline intptr_t* end_address() const;
110   inline intptr_t* bottom_address() const; // = end_address - argsize
111   inline intptr_t* sp_address() const;
112 
113 
114   inline int to_offset(intptr_t* p) const;
115   inline intptr_t* from_offset(int offset) const;
116 
117   inline bool is_empty() const;
118   inline bool is_in_chunk(void* p) const;
119   inline bool is_usable_in_chunk(void* p) const;
120 
121   inline bool is_flag(uint8_t flag) const;
122   inline bool is_flag_acquire(uint8_t flag) const;
123   inline void set_flag(uint8_t flag, bool value);
124   inline bool try_set_flags(uint8_t prev_flags, uint8_t new_flags);
125   inline void clear_flags();
126 
127   inline bool has_mixed_frames() const;
128   inline void set_has_mixed_frames(bool value);
129 






130   inline bool is_gc_mode() const;
131   inline bool is_gc_mode_acquire() const;
132   inline void set_gc_mode(bool value);
133 
134   inline bool has_bitmap() const;
135   inline void set_has_bitmap(bool value);
136 
137   inline bool has_thaw_slowpath_condition() const;
138 
139   inline bool requires_barriers();
140 
141   template <BarrierType>
142   void do_barriers();
143 
144   template <BarrierType, ChunkFrames frames, typename RegisterMapT>
145   inline void do_barriers(const StackChunkFrameStream<frames>& f, const RegisterMapT* map);
146 
147   template <typename RegisterMapT>
148   void fix_thawed_frame(const frame& f, const RegisterMapT* map);
149 





150   template <class StackChunkFrameClosureType>
151   inline void iterate_stack(StackChunkFrameClosureType* closure);
152 
153   // Derived pointers are relativized, with respect to their oop base.
154   void relativize_derived_pointers_concurrently();
155   void transform();
156 
157   inline void* gc_data() const;
158   inline BitMapView bitmap() const;
159   inline BitMap::idx_t bit_index_for(address p) const;
160   inline intptr_t* address_for_bit(BitMap::idx_t index) const;
161   template <typename OopT> inline BitMap::idx_t bit_index_for(OopT* p) const;
162   template <typename OopT> inline OopT* address_for_bit(BitMap::idx_t index) const;
163 
164   MemRegion range();
165 
166   // Returns a relative frame (with offset_sp, offset_unextended_sp, and offset_fp) that can be held
167   // during safepoints.  This is orthogonal to the relativizing of the actual content of interpreted frames.
168   // To be used, frame objects need to be derelativized with `derelativize`.
169   inline frame relativize(frame fr) const;

  1 /*
  2  * Copyright (c) 2021, 2024, 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 = 1 << 6; // Continuation was unmounted from inside VM
 65 
 66   bool try_acquire_relativization();
 67   void release_relativization();
 68 
 69 public:
 70   static inline stackChunkOop cast(oop obj);
 71 
 72   inline stackChunkOop parent() const;
 73   inline void set_parent(stackChunkOop value);
 74   template<typename P>
 75   inline void set_parent_raw(oop value);
 76   template<DecoratorSet decorators>
 77   inline void set_parent_access(oop value);
 78 
 79   inline int stack_size() const;
 80 
 81   inline int sp() const;
 82   inline void set_sp(int value);
 83 
 84   inline address pc() const;
 85   inline void set_pc(address value);
 86 
 87   inline int argsize() const;
 88   inline void set_argsize(int value);
 89 
 90   inline uint8_t flags() const;
 91   inline uint8_t flags_acquire() const;
 92   inline void set_flags(uint8_t value);
 93   inline void release_set_flags(uint8_t value);
 94 
 95   inline int max_thawing_size() const;
 96   inline void set_max_thawing_size(int value);
 97 
 98   inline uint8_t lockstack_size() const;
 99   inline void set_lockstack_size(uint8_t value);
100 
101   inline ObjectWaiter* object_waiter() const;
102   inline void set_object_waiter(ObjectWaiter* obj_waiter);
103 
104   inline ObjectMonitor* current_pending_monitor() const;
105   inline ObjectMonitor* current_waiting_monitor() const;
106 
107   inline oop cont() const;
108   template<typename P>
109   inline oop cont() const;
110   inline void set_cont(oop value);
111   template<typename P>
112   inline void set_cont_raw(oop value);
113   template<DecoratorSet decorators>
114   inline void set_cont_access(oop value);
115 
116   inline int bottom() const;
117   inline void set_bottom(int value);
118 
119   inline HeapWord* start_of_stack() const;
120 
121   inline intptr_t* start_address() const;
122   inline intptr_t* end_address() const;
123   inline intptr_t* bottom_address() const; // = end_address - argsize
124   inline intptr_t* sp_address() const;
125 
126 
127   inline int to_offset(intptr_t* p) const;
128   inline intptr_t* from_offset(int offset) const;
129 
130   inline bool is_empty() const;
131   inline bool is_in_chunk(void* p) const;
132   inline bool is_usable_in_chunk(void* p) const;
133 
134   inline bool is_flag(uint8_t flag) const;
135   inline bool is_flag_acquire(uint8_t flag) const;
136   inline void set_flag(uint8_t flag, bool value);
137   inline bool try_set_flags(uint8_t prev_flags, uint8_t new_flags);
138   inline void clear_flags();
139 
140   inline bool has_mixed_frames() const;
141   inline void set_has_mixed_frames(bool value);
142 
143   inline bool preempted() const;
144   inline void set_preempted(bool value);
145 
146   inline bool has_lockstack() const;
147   inline void set_has_lockstack(bool value);
148 
149   inline bool is_gc_mode() const;
150   inline bool is_gc_mode_acquire() const;
151   inline void set_gc_mode(bool value);
152 
153   inline bool has_bitmap() const;
154   inline void set_has_bitmap(bool value);
155 
156   inline bool has_thaw_slowpath_condition() const;
157 
158   inline bool requires_barriers();
159 
160   template <BarrierType>
161   void do_barriers();
162 
163   template <BarrierType, ChunkFrames frames, typename RegisterMapT>
164   inline void do_barriers(const StackChunkFrameStream<frames>& f, const RegisterMapT* map);
165 
166   template <typename RegisterMapT>
167   void fix_thawed_frame(const frame& f, const RegisterMapT* map);
168 
169   void transfer_lockstack(oop* start, bool requires_barriers);
170 
171   template <typename OopT, class StackChunkLockStackClosureType>
172   inline void iterate_lockstack(StackChunkLockStackClosureType* closure);
173 
174   template <class StackChunkFrameClosureType>
175   inline void iterate_stack(StackChunkFrameClosureType* closure);
176 
177   // Derived pointers are relativized, with respect to their oop base.
178   void relativize_derived_pointers_concurrently();
179   void transform();
180 
181   inline void* gc_data() const;
182   inline BitMapView bitmap() const;
183   inline BitMap::idx_t bit_index_for(address p) const;
184   inline intptr_t* address_for_bit(BitMap::idx_t index) const;
185   template <typename OopT> inline BitMap::idx_t bit_index_for(OopT* p) const;
186   template <typename OopT> inline OopT* address_for_bit(BitMap::idx_t index) const;
187 
188   MemRegion range();
189 
190   // Returns a relative frame (with offset_sp, offset_unextended_sp, and offset_fp) that can be held
191   // during safepoints.  This is orthogonal to the relativizing of the actual content of interpreted frames.
192   // To be used, frame objects need to be derelativized with `derelativize`.
193   inline frame relativize(frame fr) const;
< prev index next >