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;
|