author | coleenp |
Sun, 13 Apr 2008 17:43:42 -0400 | |
changeset 360 | 21d113ecbf6a |
parent 1 | 489c9b5090e2 |
child 382 | 02c0a63f30d6 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
2 |
* Copyright 1997-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 |
* CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 |
* have any questions. |
|
22 |
* |
|
23 |
*/ |
|
24 |
||
25 |
// oopDesc is the top baseclass for objects classes. The {name}Desc classes describe |
|
26 |
// the format of Java objects so the fields can be accessed from C++. |
|
27 |
// oopDesc is abstract. |
|
28 |
// (see oopHierarchy for complete oop class hierarchy) |
|
29 |
// |
|
30 |
// no virtual functions allowed |
|
31 |
||
32 |
// store into oop with store check |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
33 |
template <class T> void oop_store(T* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
34 |
template <class T> void oop_store(volatile T* p, oop v); |
1 | 35 |
|
36 |
// store into oop without store check |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
37 |
template <class T> void oop_store_without_check(T* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
38 |
template <class T> void oop_store_without_check(volatile T* p, oop v); |
1 | 39 |
|
40 |
||
41 |
extern bool always_do_update_barrier; |
|
42 |
||
43 |
// Forward declarations. |
|
44 |
class OopClosure; |
|
45 |
class ScanClosure; |
|
46 |
class FastScanClosure; |
|
47 |
class FilteringClosure; |
|
48 |
class BarrierSet; |
|
49 |
class CMSIsAliveClosure; |
|
50 |
||
51 |
class PSPromotionManager; |
|
52 |
class ParCompactionManager; |
|
53 |
||
54 |
class oopDesc { |
|
55 |
friend class VMStructs; |
|
56 |
private: |
|
57 |
volatile markOop _mark; |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
58 |
union _metadata { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
59 |
wideKlassOop _klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
60 |
narrowOop _compressed_klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
61 |
} _metadata; |
1 | 62 |
|
63 |
// Fast access to barrier set. Must be initialized. |
|
64 |
static BarrierSet* _bs; |
|
65 |
||
66 |
public: |
|
67 |
markOop mark() const { return _mark; } |
|
68 |
markOop* mark_addr() const { return (markOop*) &_mark; } |
|
69 |
||
70 |
void set_mark(volatile markOop m) { _mark = m; } |
|
71 |
||
72 |
void release_set_mark(markOop m); |
|
73 |
markOop cas_set_mark(markOop new_mark, markOop old_mark); |
|
74 |
||
75 |
// Used only to re-initialize the mark word (e.g., of promoted |
|
76 |
// objects during a GC) -- requires a valid klass pointer |
|
77 |
void init_mark(); |
|
78 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
79 |
klassOop klass() const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
80 |
oop* klass_addr(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
81 |
narrowOop* compressed_klass_addr(); |
1 | 82 |
|
83 |
void set_klass(klassOop k); |
|
84 |
// For when the klass pointer is being used as a linked list "next" field. |
|
85 |
void set_klass_to_list_ptr(oop k); |
|
86 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
87 |
// size of object header, aligned to platform wordSize |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
88 |
static int header_size() { return sizeof(oopDesc)/HeapWordSize; } |
1 | 89 |
|
90 |
Klass* blueprint() const; |
|
91 |
||
92 |
// Returns whether this is an instance of k or an instance of a subclass of k |
|
93 |
bool is_a(klassOop k) const; |
|
94 |
||
95 |
// Returns the actual oop size of the object |
|
96 |
int size(); |
|
97 |
||
98 |
// Sometimes (for complicated concurrency-related reasons), it is useful |
|
99 |
// to be able to figure out the size of an object knowing its klass. |
|
100 |
int size_given_klass(Klass* klass); |
|
101 |
||
102 |
// Some perm gen objects are not parseble immediately after |
|
103 |
// installation of their klass pointer. |
|
104 |
bool is_parsable(); |
|
105 |
||
106 |
// type test operations (inlined in oop.inline.h) |
|
107 |
bool is_instance() const; |
|
108 |
bool is_instanceRef() const; |
|
109 |
bool is_array() const; |
|
110 |
bool is_objArray() const; |
|
111 |
bool is_symbol() const; |
|
112 |
bool is_klass() const; |
|
113 |
bool is_thread() const; |
|
114 |
bool is_method() const; |
|
115 |
bool is_constMethod() const; |
|
116 |
bool is_methodData() const; |
|
117 |
bool is_constantPool() const; |
|
118 |
bool is_constantPoolCache() const; |
|
119 |
bool is_typeArray() const; |
|
120 |
bool is_javaArray() const; |
|
121 |
bool is_compiledICHolder() const; |
|
122 |
||
123 |
private: |
|
124 |
// field addresses in oop |
|
125 |
void* field_base(int offset) const; |
|
126 |
||
127 |
jbyte* byte_field_addr(int offset) const; |
|
128 |
jchar* char_field_addr(int offset) const; |
|
129 |
jboolean* bool_field_addr(int offset) const; |
|
130 |
jint* int_field_addr(int offset) const; |
|
131 |
jshort* short_field_addr(int offset) const; |
|
132 |
jlong* long_field_addr(int offset) const; |
|
133 |
jfloat* float_field_addr(int offset) const; |
|
134 |
jdouble* double_field_addr(int offset) const; |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
135 |
address* address_field_addr(int offset) const; |
1 | 136 |
|
137 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
138 |
// Need this as public for garbage collection. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
139 |
template <class T> T* obj_field_addr(int offset) const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
140 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
141 |
static bool is_null(oop obj); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
142 |
static bool is_null(narrowOop obj); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
143 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
144 |
// Decode an oop pointer from a narrowOop if compressed. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
145 |
// These are overloaded for oop and narrowOop as are the other functions |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
146 |
// below so that they can be called in template functions. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
147 |
static oop decode_heap_oop_not_null(oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
148 |
static oop decode_heap_oop_not_null(narrowOop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
149 |
static oop decode_heap_oop(oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
150 |
static oop decode_heap_oop(narrowOop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
151 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
152 |
// Encode an oop pointer to a narrow oop. The or_null versions accept |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
153 |
// null oop pointer, others do not in order to eliminate the |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
154 |
// null checking branches. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
155 |
static narrowOop encode_heap_oop_not_null(oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
156 |
static narrowOop encode_heap_oop(oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
157 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
158 |
// Load an oop out of the Java heap |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
159 |
static narrowOop load_heap_oop(narrowOop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
160 |
static oop load_heap_oop(oop* p); |
1 | 161 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
162 |
// Load an oop out of Java heap and decode it to an uncompressed oop. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
163 |
static oop load_decode_heap_oop_not_null(narrowOop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
164 |
static oop load_decode_heap_oop_not_null(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
165 |
static oop load_decode_heap_oop(narrowOop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
166 |
static oop load_decode_heap_oop(oop* p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
167 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
168 |
// Store an oop into the heap. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
169 |
static void store_heap_oop(narrowOop* p, narrowOop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
170 |
static void store_heap_oop(oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
171 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
172 |
// Encode oop if UseCompressedOops and store into the heap. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
173 |
static void encode_store_heap_oop_not_null(narrowOop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
174 |
static void encode_store_heap_oop_not_null(oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
175 |
static void encode_store_heap_oop(narrowOop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
176 |
static void encode_store_heap_oop(oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
177 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
178 |
static void release_store_heap_oop(volatile narrowOop* p, narrowOop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
179 |
static void release_store_heap_oop(volatile oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
180 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
181 |
static void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
182 |
static void release_encode_store_heap_oop_not_null(volatile oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
183 |
static void release_encode_store_heap_oop(volatile narrowOop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
184 |
static void release_encode_store_heap_oop(volatile oop* p, oop v); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
185 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
186 |
static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
187 |
static oop atomic_compare_exchange_oop(oop exchange_value, |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
188 |
volatile HeapWord *dest, |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
189 |
oop compare_value); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
190 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
191 |
// Access to fields in a instanceOop through these methods. |
1 | 192 |
oop obj_field(int offset) const; |
193 |
void obj_field_put(int offset, oop value); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
194 |
void obj_field_raw_put(int offset, oop value); |
1 | 195 |
|
196 |
jbyte byte_field(int offset) const; |
|
197 |
void byte_field_put(int offset, jbyte contents); |
|
198 |
||
199 |
jchar char_field(int offset) const; |
|
200 |
void char_field_put(int offset, jchar contents); |
|
201 |
||
202 |
jboolean bool_field(int offset) const; |
|
203 |
void bool_field_put(int offset, jboolean contents); |
|
204 |
||
205 |
jint int_field(int offset) const; |
|
206 |
void int_field_put(int offset, jint contents); |
|
207 |
||
208 |
jshort short_field(int offset) const; |
|
209 |
void short_field_put(int offset, jshort contents); |
|
210 |
||
211 |
jlong long_field(int offset) const; |
|
212 |
void long_field_put(int offset, jlong contents); |
|
213 |
||
214 |
jfloat float_field(int offset) const; |
|
215 |
void float_field_put(int offset, jfloat contents); |
|
216 |
||
217 |
jdouble double_field(int offset) const; |
|
218 |
void double_field_put(int offset, jdouble contents); |
|
219 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
220 |
address address_field(int offset) const; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
221 |
void address_field_put(int offset, address contents); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
222 |
|
1 | 223 |
oop obj_field_acquire(int offset) const; |
224 |
void release_obj_field_put(int offset, oop value); |
|
225 |
||
226 |
jbyte byte_field_acquire(int offset) const; |
|
227 |
void release_byte_field_put(int offset, jbyte contents); |
|
228 |
||
229 |
jchar char_field_acquire(int offset) const; |
|
230 |
void release_char_field_put(int offset, jchar contents); |
|
231 |
||
232 |
jboolean bool_field_acquire(int offset) const; |
|
233 |
void release_bool_field_put(int offset, jboolean contents); |
|
234 |
||
235 |
jint int_field_acquire(int offset) const; |
|
236 |
void release_int_field_put(int offset, jint contents); |
|
237 |
||
238 |
jshort short_field_acquire(int offset) const; |
|
239 |
void release_short_field_put(int offset, jshort contents); |
|
240 |
||
241 |
jlong long_field_acquire(int offset) const; |
|
242 |
void release_long_field_put(int offset, jlong contents); |
|
243 |
||
244 |
jfloat float_field_acquire(int offset) const; |
|
245 |
void release_float_field_put(int offset, jfloat contents); |
|
246 |
||
247 |
jdouble double_field_acquire(int offset) const; |
|
248 |
void release_double_field_put(int offset, jdouble contents); |
|
249 |
||
250 |
// printing functions for VM debugging |
|
251 |
void print_on(outputStream* st) const; // First level print |
|
252 |
void print_value_on(outputStream* st) const; // Second level print. |
|
253 |
void print_address_on(outputStream* st) const; // Address printing |
|
254 |
||
255 |
// printing on default output stream |
|
256 |
void print(); |
|
257 |
void print_value(); |
|
258 |
void print_address(); |
|
259 |
||
260 |
// return the print strings |
|
261 |
char* print_string(); |
|
262 |
char* print_value_string(); |
|
263 |
||
264 |
// verification operations |
|
265 |
void verify_on(outputStream* st); |
|
266 |
void verify(); |
|
267 |
void verify_old_oop(oop* p, bool allow_dirty); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
268 |
void verify_old_oop(narrowOop* p, bool allow_dirty); |
1 | 269 |
|
270 |
// tells whether this oop is partially constructed (gc during class loading) |
|
271 |
bool partially_loaded(); |
|
272 |
void set_partially_loaded(); |
|
273 |
||
274 |
// locking operations |
|
275 |
bool is_locked() const; |
|
276 |
bool is_unlocked() const; |
|
277 |
bool has_bias_pattern() const; |
|
278 |
||
279 |
// asserts |
|
280 |
bool is_oop(bool ignore_mark_word = false) const; |
|
281 |
bool is_oop_or_null(bool ignore_mark_word = false) const; |
|
282 |
#ifndef PRODUCT |
|
283 |
bool is_unlocked_oop() const; |
|
284 |
#endif |
|
285 |
||
286 |
// garbage collection |
|
287 |
bool is_gc_marked() const; |
|
288 |
// Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL |
|
289 |
// reference field in "this". |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
290 |
void follow_contents(void); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
291 |
void follow_header(void); |
1 | 292 |
|
293 |
#ifndef SERIALGC |
|
294 |
// Parallel Scavenge |
|
295 |
void copy_contents(PSPromotionManager* pm); |
|
296 |
void push_contents(PSPromotionManager* pm); |
|
297 |
||
298 |
// Parallel Old |
|
299 |
void update_contents(ParCompactionManager* cm); |
|
300 |
void update_contents(ParCompactionManager* cm, |
|
301 |
HeapWord* begin_limit, |
|
302 |
HeapWord* end_limit); |
|
303 |
void update_contents(ParCompactionManager* cm, |
|
304 |
klassOop old_klass, |
|
305 |
HeapWord* begin_limit, |
|
306 |
HeapWord* end_limit); |
|
307 |
||
308 |
void follow_contents(ParCompactionManager* cm); |
|
309 |
void follow_header(ParCompactionManager* cm); |
|
310 |
#endif // SERIALGC |
|
311 |
||
312 |
bool is_perm() const; |
|
313 |
bool is_perm_or_null() const; |
|
314 |
bool is_shared() const; |
|
315 |
bool is_shared_readonly() const; |
|
316 |
bool is_shared_readwrite() const; |
|
317 |
||
318 |
// Forward pointer operations for scavenge |
|
319 |
bool is_forwarded() const; |
|
320 |
||
321 |
void forward_to(oop p); |
|
322 |
bool cas_forward_to(oop p, markOop compare); |
|
323 |
||
324 |
#ifndef SERIALGC |
|
325 |
// Like "forward_to", but inserts the forwarding pointer atomically. |
|
326 |
// Exactly one thread succeeds in inserting the forwarding pointer, and |
|
327 |
// this call returns "NULL" for that thread; any other thread has the |
|
328 |
// value of the forwarding pointer returned and does not modify "this". |
|
329 |
oop forward_to_atomic(oop p); |
|
330 |
#endif // SERIALGC |
|
331 |
||
332 |
oop forwardee() const; |
|
333 |
||
334 |
// Age of object during scavenge |
|
335 |
int age() const; |
|
336 |
void incr_age(); |
|
337 |
||
338 |
// Adjust all pointers in this object to point at it's forwarded location and |
|
339 |
// return the size of this oop. This is used by the MarkSweep collector. |
|
340 |
int adjust_pointers(); |
|
341 |
void adjust_header(); |
|
342 |
||
343 |
#ifndef SERIALGC |
|
344 |
// Parallel old |
|
345 |
void update_header(); |
|
346 |
void update_header(HeapWord* beg_addr, HeapWord* end_addr); |
|
347 |
#endif // SERIALGC |
|
348 |
||
349 |
// mark-sweep support |
|
350 |
void follow_body(int begin, int end); |
|
351 |
||
352 |
// Fast access to barrier set |
|
353 |
static BarrierSet* bs() { return _bs; } |
|
354 |
static void set_bs(BarrierSet* bs) { _bs = bs; } |
|
355 |
||
356 |
// iterators, returns size of object |
|
357 |
#define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
|
358 |
int oop_iterate(OopClosureType* blk); \ |
|
359 |
int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr. |
|
360 |
||
361 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL) |
|
362 |
ALL_OOP_OOP_ITERATE_CLOSURES_3(OOP_ITERATE_DECL) |
|
363 |
||
364 |
void oop_iterate_header(OopClosure* blk); |
|
365 |
void oop_iterate_header(OopClosure* blk, MemRegion mr); |
|
366 |
||
367 |
// identity hash; returns the identity hash key (computes it if necessary) |
|
368 |
// NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a |
|
369 |
// safepoint if called on a biased object. Calling code must be aware of that. |
|
370 |
intptr_t identity_hash(); |
|
371 |
intptr_t slow_identity_hash(); |
|
372 |
||
373 |
// marks are forwarded to stack when object is locked |
|
374 |
bool has_displaced_mark() const; |
|
375 |
markOop displaced_mark() const; |
|
376 |
void set_displaced_mark(markOop m); |
|
377 |
||
378 |
// for code generation |
|
379 |
static int mark_offset_in_bytes() { return offset_of(oopDesc, _mark); } |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
380 |
static int klass_offset_in_bytes() { return offset_of(oopDesc, _metadata._klass); } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
381 |
static int klass_gap_offset_in_bytes(); |
1 | 382 |
}; |