1 /*
2 * Copyright (c) 1997, 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_RUNTIME_HANDLES_HPP
26 #define SHARE_RUNTIME_HANDLES_HPP
27
28 #include "memory/arena.hpp"
29 #include "oops/oop.hpp"
30 #include "oops/oopsHierarchy.hpp"
31
32 class InlineKlass;
33 class InstanceKlass;
34 class Klass;
35 class Thread;
36
37 //------------------------------------------------------------------------------------------------------------------------
38 // In order to preserve oops during garbage collection, they should be
39 // allocated and passed around via Handles within the VM. A handle is
40 // simply an extra indirection allocated in a thread local handle area.
41 //
42 // A handle is a value object, so it can be passed around as a value, can
43 // be used as a parameter w/o using &-passing, and can be returned as a
44 // return value.
45 //
46 // oop parameters and return types should be Handles whenever feasible.
47 //
48 // Handles are declared in a straight-forward manner, e.g.
49 //
50 // oop obj = ...;
51 // Handle h2(thread, obj); // allocate a new handle in thread
52 // Handle h3; // declare handle only, no allocation occurs
53 // ...
54 // h3 = h1; // make h3 refer to same indirection as h1
55 // oop obj2 = h2(); // get handle value
56 // h1->print(); // invoking operation on oop
57 //
58 // Handles are specialized for different oop types to provide extra type
59 // information and avoid unnecessary casting. For each oop type xxxOop
60 // there is a corresponding handle called xxxHandle.
61
62 //------------------------------------------------------------------------------------------------------------------------
63 // Base class for all handles. Provides overloading of frequently
64 // used operators for ease of use.
65
66 class Handle {
67 private:
68 oop* _handle;
69
70 protected:
71 oop obj() const { return _handle == nullptr ? (oop)nullptr : *_handle; }
72 oop non_null_obj() const { assert(_handle != nullptr, "resolving null handle"); return *_handle; }
73
74 public:
75 // Constructors
76 Handle() { _handle = nullptr; }
77 inline Handle(Thread* thread, oop obj);
78
79 // General access
80 oop operator () () const { return obj(); }
81 oop operator -> () const { return non_null_obj(); }
82
83 bool operator == (oop o) const { return obj() == o; }
84 bool operator != (oop o) const { return obj() != o; }
85 bool operator == (const Handle& h) const { return obj() == h.obj(); }
86 bool operator != (const Handle& h) const { return obj() != h.obj(); }
87
88 // Null checks
89 bool is_null() const { return _handle == nullptr; }
90 bool not_null() const { return _handle != nullptr; }
91
92 // Debugging
93 void print() { obj()->print(); }
94
95 // Direct interface, use very sparingly.
96 // Used by JavaCalls to quickly convert handles and to create handles static data structures.
97 // Constructor takes a dummy argument to prevent unintentional type conversion in C++.
98 Handle(oop *handle, bool dummy) { _handle = handle; }
99
100 // Raw handle access. Allows easy duplication of Handles. This can be very unsafe
101 // since duplicates is only valid as long as original handle is alive.
102 oop* raw_value() const { return _handle; }
103 static oop raw_resolve(oop *handle) { return handle == nullptr ? (oop)nullptr : *handle; }
104
105 inline void replace(oop obj);
106 };
107
108 // Specific Handles for different oop types
109 #define DEF_HANDLE(type, is_a) \
110 class type##Handle: public Handle { \
111 protected: \
112 type##Oop obj() const { return (type##Oop)Handle::obj(); } \
113 type##Oop non_null_obj() const { return (type##Oop)Handle::non_null_obj(); } \
114 \
115 public: \
116 /* Constructors */ \
117 type##Handle () : Handle() {} \
118 inline type##Handle (Thread* thread, type##Oop obj); \
119 type##Handle (oop *handle, bool dummy) : Handle(handle, dummy) {} \
120 \
121 /* Operators for ease of use */ \
122 type##Oop operator () () const { return obj(); } \
123 type##Oop operator -> () const { return non_null_obj(); } \
124 };
125
126
127 DEF_HANDLE(instance , is_instance_noinline )
128 DEF_HANDLE(stackChunk , is_stackChunk_noinline )
129 DEF_HANDLE(array , is_array_noinline )
130 DEF_HANDLE(objArray , is_objArray_noinline )
131 DEF_HANDLE(typeArray , is_typeArray_noinline )
132 DEF_HANDLE(flatArray , is_flatArray_noinline )
133
134 //------------------------------------------------------------------------------------------------------------------------
135
136 // Metadata Handles. Unlike oop Handles these are needed to prevent metadata
137 // from being reclaimed by RedefineClasses.
138 // Metadata Handles should be passed around as const references to avoid copy construction
139 // and destruction for parameters.
140
141 // Specific Handles for different oop types
142 #define DEF_METADATA_HANDLE(name, type) \
143 class name##Handle; \
144 class name##Handle : public StackObj { \
145 type* _value; \
146 Thread* _thread; \
147 protected: \
148 type* obj() const { return _value; } \
149 type* non_null_obj() const { assert(_value != nullptr, "resolving null _value"); return _value; } \
150 \
151 public: \
152 /* Constructors */ \
153 name##Handle () : _value(nullptr), _thread(nullptr) {} \
154 name##Handle (Thread* thread, type* obj); \
155 \
156 name##Handle (const name##Handle &h); \
157 name##Handle& operator=(const name##Handle &s); \
158 \
159 /* Destructor */ \
160 ~name##Handle (); \
161 void remove(); \
162 \
163 /* Operators for ease of use */ \
164 type* operator () () const { return obj(); } \
165 type* operator -> () const { return non_null_obj(); } \
166 \
167 bool operator == (type* o) const { return obj() == o; } \
168 bool operator == (const name##Handle& h) const { return obj() == h.obj(); } \
169 \
170 /* Null checks */ \
171 bool is_null() const { return _value == nullptr; } \
172 bool not_null() const { return _value != nullptr; } \
173 };
174
175
176 DEF_METADATA_HANDLE(method, Method)
177 DEF_METADATA_HANDLE(constantPool, ConstantPool)
178
179 //------------------------------------------------------------------------------------------------------------------------
180 // Thread local handle area
181 class HandleArea: public Arena {
182 friend class HandleMark;
183 friend class NoHandleMark;
184 friend class ResetNoHandleMark;
185 #ifdef ASSERT
186 int _handle_mark_nesting;
187 int _no_handle_mark_nesting;
188 #endif
189 HandleArea* _prev; // link to outer (older) area
190 public:
191 // Constructor
192 HandleArea(MemTag mem_tag, HandleArea* prev) : Arena(mem_tag, Tag::tag_ha, Chunk::tiny_size) {
193 debug_only(_handle_mark_nesting = 0);
194 debug_only(_no_handle_mark_nesting = 0);
195 _prev = prev;
196 }
197
198 // Handle allocation
199 private:
200 oop* real_allocate_handle(oop obj) {
201 oop* handle = (oop*)internal_amalloc(oopSize);
202 *handle = obj;
203 return handle;
204 }
205 public:
206 #ifdef ASSERT
207 oop* allocate_handle(oop obj);
208 oop* allocate_null_handle();
209 #else
210 oop* allocate_handle(oop obj) { return real_allocate_handle(obj); }
211 oop* allocate_null_handle() { return allocate_handle(nullptr); }
212 #endif
213
214 // Garbage collection support
215 void oops_do(OopClosure* f);
216
217 debug_only(bool no_handle_mark_active() { return _no_handle_mark_nesting > 0; })
218 };
219
220
221 //------------------------------------------------------------------------------------------------------------------------
222 // Handles are allocated in a (growable) thread local handle area. Deallocation
223 // is managed using a HandleMark. It should normally not be necessary to use
224 // HandleMarks manually.
225 //
226 // A HandleMark constructor will record the current handle area top, and the
227 // destructor will reset the top, destroying all handles allocated in between.
228 // The following code will therefore NOT work:
229 //
230 // Handle h;
231 // {
232 // HandleMark hm(THREAD);
233 // h = Handle(THREAD, obj);
234 // }
235 // h()->print(); // WRONG, h destroyed by HandleMark destructor.
236 //
237 // If h has to be preserved, it can be converted to an oop or a local JNI handle
238 // across the HandleMark boundary.
239
240 // The base class of HandleMark should have been StackObj but we also heap allocate
241 // a HandleMark when a thread is created. The operator new is for this special case.
242
243 class HandleMark {
244 private:
245 Thread *_thread; // thread that owns this mark
246 HandleArea *_area; // saved handle area
247 Chunk *_chunk; // saved arena chunk
248 char *_hwm, *_max; // saved arena info
249 size_t _size_in_bytes; // size of handle area
250 // Link to previous active HandleMark in thread
251 HandleMark* _previous_handle_mark;
252
253 void initialize(Thread* thread); // common code for constructors
254 void set_previous_handle_mark(HandleMark* mark) { _previous_handle_mark = mark; }
255 HandleMark* previous_handle_mark() const { return _previous_handle_mark; }
256
257 size_t size_in_bytes() const { return _size_in_bytes; }
258 // remove all chunks beginning with the next
259 void chop_later_chunks();
260 public:
261 HandleMark(Thread* thread) { initialize(thread); }
262 ~HandleMark();
263
264 // Functions used by HandleMarkCleaner
265 // called in the constructor of HandleMarkCleaner
266 void push();
267 // called in the destructor of HandleMarkCleaner
268 void pop_and_restore();
269 // overloaded operators
270 void* operator new(size_t size) throw();
271 void* operator new [](size_t size) throw();
272 void operator delete(void* p);
273 void operator delete[](void* p);
274 };
275
276 //------------------------------------------------------------------------------------------------------------------------
277 // A NoHandleMark stack object will verify that no handles are allocated
278 // in its scope. Enabled in debug mode only.
279
280 class NoHandleMark: public StackObj {
281 public:
282 #ifdef ASSERT
283 NoHandleMark();
284 ~NoHandleMark();
285 #else
286 NoHandleMark() {}
287 ~NoHandleMark() {}
288 #endif
289 };
290
291
292 // ResetNoHandleMark is called in a context where there is an enclosing
293 // NoHandleMark. A thread in _thread_in_native must not create handles so
294 // this is used when transitioning via ThreadInVMfromNative.
295 class ResetNoHandleMark: public StackObj {
296 int _no_handle_mark_nesting;
297 public:
298 #ifdef ASSERT
299 ResetNoHandleMark();
300 ~ResetNoHandleMark();
301 #else
302 ResetNoHandleMark() {}
303 ~ResetNoHandleMark() {}
304 #endif
305 };
306
307 // The HandleMarkCleaner is a faster version of HandleMark.
308 // It relies on the fact that there is a HandleMark further
309 // down the stack (in JavaCalls::call_helper), and just resets
310 // to the saved values in that HandleMark.
311
312 class HandleMarkCleaner: public StackObj {
313 private:
314 Thread* _thread;
315 public:
316 inline HandleMarkCleaner(Thread* thread);
317 inline ~HandleMarkCleaner();
318 };
319
320 #endif // SHARE_RUNTIME_HANDLES_HPP