author | tonyp |
Thu, 22 Jul 2010 10:27:41 -0400 | |
changeset 6248 | 2e661807cef0 |
parent 5702 | 201c5cde25bb |
child 7397 | 5b173b4ca846 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4493
diff
changeset
|
2 |
* Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4493
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4493
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4493
diff
changeset
|
21 |
* questions. |
1 | 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 |
|
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
3908
diff
changeset
|
33 |
template <class T> inline void oop_store(T* p, oop v); |
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
3908
diff
changeset
|
34 |
template <class T> inline void oop_store(volatile T* p, oop v); |
1 | 35 |
|
36 |
// store into oop without store check |
|
4493
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
3908
diff
changeset
|
37 |
template <class T> inline void oop_store_without_check(T* p, oop v); |
9204129f065e
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
3908
diff
changeset
|
38 |
template <class T> inline void oop_store_without_check(volatile T* p, oop v); |
1 | 39 |
|
40 |
extern bool always_do_update_barrier; |
|
41 |
||
42 |
// Forward declarations. |
|
43 |
class OopClosure; |
|
44 |
class ScanClosure; |
|
45 |
class FastScanClosure; |
|
46 |
class FilteringClosure; |
|
47 |
class BarrierSet; |
|
48 |
class CMSIsAliveClosure; |
|
49 |
||
50 |
class PSPromotionManager; |
|
51 |
class ParCompactionManager; |
|
52 |
||
53 |
class oopDesc { |
|
54 |
friend class VMStructs; |
|
55 |
private: |
|
56 |
volatile markOop _mark; |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
57 |
union _metadata { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
58 |
wideKlassOop _klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
59 |
narrowOop _compressed_klass; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
60 |
} _metadata; |
1 | 61 |
|
62 |
// Fast access to barrier set. Must be initialized. |
|
63 |
static BarrierSet* _bs; |
|
64 |
||
65 |
public: |
|
66 |
markOop mark() const { return _mark; } |
|
67 |
markOop* mark_addr() const { return (markOop*) &_mark; } |
|
68 |
||
69 |
void set_mark(volatile markOop m) { _mark = m; } |
|
70 |
||
71 |
void release_set_mark(markOop m); |
|
72 |
markOop cas_set_mark(markOop new_mark, markOop old_mark); |
|
73 |
||
74 |
// Used only to re-initialize the mark word (e.g., of promoted |
|
75 |
// objects during a GC) -- requires a valid klass pointer |
|
76 |
void init_mark(); |
|
77 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
78 |
klassOop klass() const; |
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
79 |
klassOop klass_or_null() const volatile; |
360
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); |
|
593
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
84 |
|
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
85 |
// For klass field compression |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
86 |
int klass_gap() const; |
803947e176bd
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
382
diff
changeset
|
87 |
void set_klass_gap(int z); |
1 | 88 |
// For when the klass pointer is being used as a linked list "next" field. |
89 |
void set_klass_to_list_ptr(oop k); |
|
90 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
91 |
// 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
|
92 |
static int header_size() { return sizeof(oopDesc)/HeapWordSize; } |
1 | 93 |
|
94 |
Klass* blueprint() const; |
|
95 |
||
96 |
// Returns whether this is an instance of k or an instance of a subclass of k |
|
97 |
bool is_a(klassOop k) const; |
|
98 |
||
99 |
// Returns the actual oop size of the object |
|
100 |
int size(); |
|
101 |
||
102 |
// Sometimes (for complicated concurrency-related reasons), it is useful |
|
103 |
// to be able to figure out the size of an object knowing its klass. |
|
104 |
int size_given_klass(Klass* klass); |
|
105 |
||
106 |
// Some perm gen objects are not parseble immediately after |
|
107 |
// installation of their klass pointer. |
|
108 |
bool is_parsable(); |
|
109 |
||
1894
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
110 |
// Some perm gen objects that have been allocated and initialized |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
111 |
// can be changed by the VM when not at a safe point (class rededfinition |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
112 |
// is an example). Such objects should not be examined by the |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
113 |
// concurrent processing of a garbage collector if is_conc_safe() |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
114 |
// returns false. |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
115 |
bool is_conc_safe(); |
5c343868d071
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
1388
diff
changeset
|
116 |
|
1 | 117 |
// type test operations (inlined in oop.inline.h) |
118 |
bool is_instance() const; |
|
119 |
bool is_instanceRef() const; |
|
120 |
bool is_array() const; |
|
121 |
bool is_objArray() const; |
|
122 |
bool is_symbol() const; |
|
123 |
bool is_klass() const; |
|
124 |
bool is_thread() const; |
|
125 |
bool is_method() const; |
|
126 |
bool is_constMethod() const; |
|
127 |
bool is_methodData() const; |
|
128 |
bool is_constantPool() const; |
|
129 |
bool is_constantPoolCache() const; |
|
130 |
bool is_typeArray() const; |
|
131 |
bool is_javaArray() const; |
|
132 |
bool is_compiledICHolder() const; |
|
133 |
||
134 |
private: |
|
135 |
// field addresses in oop |
|
136 |
void* field_base(int offset) const; |
|
137 |
||
138 |
jbyte* byte_field_addr(int offset) const; |
|
139 |
jchar* char_field_addr(int offset) const; |
|
140 |
jboolean* bool_field_addr(int offset) const; |
|
141 |
jint* int_field_addr(int offset) const; |
|
142 |
jshort* short_field_addr(int offset) const; |
|
143 |
jlong* long_field_addr(int offset) const; |
|
144 |
jfloat* float_field_addr(int offset) const; |
|
145 |
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
|
146 |
address* address_field_addr(int offset) const; |
1 | 147 |
|
148 |
public: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
149 |
// 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
|
150 |
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
|
151 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
152 |
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
|
153 |
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
|
154 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
155 |
// 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
|
156 |
// 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
|
157 |
// 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
|
158 |
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
|
159 |
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
|
160 |
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
|
161 |
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
|
162 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
163 |
// 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
|
164 |
// 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
|
165 |
// null checking branches. |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
166 |
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
|
167 |
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
|
168 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
169 |
// 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
|
170 |
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
|
171 |
static oop load_heap_oop(oop* p); |
1 | 172 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
173 |
// 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
|
174 |
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
|
175 |
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
|
176 |
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
|
177 |
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
|
178 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
179 |
// 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
|
180 |
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
|
181 |
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
|
182 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
183 |
// 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
|
184 |
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
|
185 |
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
|
186 |
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
|
187 |
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
|
188 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
189 |
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
|
190 |
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
|
191 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
192 |
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
|
193 |
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
|
194 |
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
|
195 |
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
|
196 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
197 |
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
|
198 |
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
|
199 |
volatile HeapWord *dest, |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
200 |
oop compare_value); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
201 |
|
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
202 |
// Access to fields in a instanceOop through these methods. |
1 | 203 |
oop obj_field(int offset) const; |
204 |
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
|
205 |
void obj_field_raw_put(int offset, oop value); |
1 | 206 |
|
207 |
jbyte byte_field(int offset) const; |
|
208 |
void byte_field_put(int offset, jbyte contents); |
|
209 |
||
210 |
jchar char_field(int offset) const; |
|
211 |
void char_field_put(int offset, jchar contents); |
|
212 |
||
213 |
jboolean bool_field(int offset) const; |
|
214 |
void bool_field_put(int offset, jboolean contents); |
|
215 |
||
216 |
jint int_field(int offset) const; |
|
217 |
void int_field_put(int offset, jint contents); |
|
218 |
||
219 |
jshort short_field(int offset) const; |
|
220 |
void short_field_put(int offset, jshort contents); |
|
221 |
||
222 |
jlong long_field(int offset) const; |
|
223 |
void long_field_put(int offset, jlong contents); |
|
224 |
||
225 |
jfloat float_field(int offset) const; |
|
226 |
void float_field_put(int offset, jfloat contents); |
|
227 |
||
228 |
jdouble double_field(int offset) const; |
|
229 |
void double_field_put(int offset, jdouble contents); |
|
230 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
231 |
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
|
232 |
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
|
233 |
|
1 | 234 |
oop obj_field_acquire(int offset) const; |
235 |
void release_obj_field_put(int offset, oop value); |
|
236 |
||
237 |
jbyte byte_field_acquire(int offset) const; |
|
238 |
void release_byte_field_put(int offset, jbyte contents); |
|
239 |
||
240 |
jchar char_field_acquire(int offset) const; |
|
241 |
void release_char_field_put(int offset, jchar contents); |
|
242 |
||
243 |
jboolean bool_field_acquire(int offset) const; |
|
244 |
void release_bool_field_put(int offset, jboolean contents); |
|
245 |
||
246 |
jint int_field_acquire(int offset) const; |
|
247 |
void release_int_field_put(int offset, jint contents); |
|
248 |
||
249 |
jshort short_field_acquire(int offset) const; |
|
250 |
void release_short_field_put(int offset, jshort contents); |
|
251 |
||
252 |
jlong long_field_acquire(int offset) const; |
|
253 |
void release_long_field_put(int offset, jlong contents); |
|
254 |
||
255 |
jfloat float_field_acquire(int offset) const; |
|
256 |
void release_float_field_put(int offset, jfloat contents); |
|
257 |
||
258 |
jdouble double_field_acquire(int offset) const; |
|
259 |
void release_double_field_put(int offset, jdouble contents); |
|
260 |
||
2534 | 261 |
address address_field_acquire(int offset) const; |
262 |
void release_address_field_put(int offset, address contents); |
|
263 |
||
1 | 264 |
// printing functions for VM debugging |
265 |
void print_on(outputStream* st) const; // First level print |
|
266 |
void print_value_on(outputStream* st) const; // Second level print. |
|
267 |
void print_address_on(outputStream* st) const; // Address printing |
|
268 |
||
269 |
// printing on default output stream |
|
270 |
void print(); |
|
271 |
void print_value(); |
|
272 |
void print_address(); |
|
273 |
||
274 |
// return the print strings |
|
275 |
char* print_string(); |
|
276 |
char* print_value_string(); |
|
277 |
||
278 |
// verification operations |
|
279 |
void verify_on(outputStream* st); |
|
280 |
void verify(); |
|
281 |
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
|
282 |
void verify_old_oop(narrowOop* p, bool allow_dirty); |
1 | 283 |
|
284 |
// tells whether this oop is partially constructed (gc during class loading) |
|
285 |
bool partially_loaded(); |
|
286 |
void set_partially_loaded(); |
|
287 |
||
288 |
// locking operations |
|
289 |
bool is_locked() const; |
|
290 |
bool is_unlocked() const; |
|
291 |
bool has_bias_pattern() const; |
|
292 |
||
293 |
// asserts |
|
294 |
bool is_oop(bool ignore_mark_word = false) const; |
|
295 |
bool is_oop_or_null(bool ignore_mark_word = false) const; |
|
296 |
#ifndef PRODUCT |
|
297 |
bool is_unlocked_oop() const; |
|
298 |
#endif |
|
299 |
||
300 |
// garbage collection |
|
301 |
bool is_gc_marked() const; |
|
302 |
// Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL |
|
303 |
// reference field in "this". |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
304 |
void follow_contents(void); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
1
diff
changeset
|
305 |
void follow_header(void); |
1 | 306 |
|
307 |
#ifndef SERIALGC |
|
308 |
// Parallel Scavenge |
|
309 |
void push_contents(PSPromotionManager* pm); |
|
310 |
||
311 |
// Parallel Old |
|
312 |
void update_contents(ParCompactionManager* cm); |
|
313 |
void update_contents(ParCompactionManager* cm, |
|
314 |
HeapWord* begin_limit, |
|
315 |
HeapWord* end_limit); |
|
316 |
void update_contents(ParCompactionManager* cm, |
|
317 |
klassOop old_klass, |
|
318 |
HeapWord* begin_limit, |
|
319 |
HeapWord* end_limit); |
|
320 |
||
321 |
void follow_contents(ParCompactionManager* cm); |
|
322 |
void follow_header(ParCompactionManager* cm); |
|
323 |
#endif // SERIALGC |
|
324 |
||
325 |
bool is_perm() const; |
|
326 |
bool is_perm_or_null() const; |
|
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
2534
diff
changeset
|
327 |
bool is_scavengable() const; |
1 | 328 |
bool is_shared() const; |
329 |
bool is_shared_readonly() const; |
|
330 |
bool is_shared_readwrite() const; |
|
331 |
||
332 |
// Forward pointer operations for scavenge |
|
333 |
bool is_forwarded() const; |
|
334 |
||
335 |
void forward_to(oop p); |
|
336 |
bool cas_forward_to(oop p, markOop compare); |
|
337 |
||
338 |
#ifndef SERIALGC |
|
339 |
// Like "forward_to", but inserts the forwarding pointer atomically. |
|
340 |
// Exactly one thread succeeds in inserting the forwarding pointer, and |
|
341 |
// this call returns "NULL" for that thread; any other thread has the |
|
342 |
// value of the forwarding pointer returned and does not modify "this". |
|
343 |
oop forward_to_atomic(oop p); |
|
344 |
#endif // SERIALGC |
|
345 |
||
346 |
oop forwardee() const; |
|
347 |
||
348 |
// Age of object during scavenge |
|
349 |
int age() const; |
|
350 |
void incr_age(); |
|
351 |
||
352 |
// Adjust all pointers in this object to point at it's forwarded location and |
|
353 |
// return the size of this oop. This is used by the MarkSweep collector. |
|
354 |
int adjust_pointers(); |
|
355 |
void adjust_header(); |
|
356 |
||
357 |
#ifndef SERIALGC |
|
358 |
// Parallel old |
|
359 |
void update_header(); |
|
360 |
void update_header(HeapWord* beg_addr, HeapWord* end_addr); |
|
361 |
#endif // SERIALGC |
|
362 |
||
363 |
// mark-sweep support |
|
364 |
void follow_body(int begin, int end); |
|
365 |
||
366 |
// Fast access to barrier set |
|
367 |
static BarrierSet* bs() { return _bs; } |
|
368 |
static void set_bs(BarrierSet* bs) { _bs = bs; } |
|
369 |
||
370 |
// iterators, returns size of object |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
371 |
#define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
1 | 372 |
int oop_iterate(OopClosureType* blk); \ |
373 |
int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr. |
|
374 |
||
375 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL) |
|
1374
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
376 |
ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL) |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
377 |
|
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
378 |
#ifndef SERIALGC |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
379 |
|
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
380 |
#define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
381 |
int oop_iterate_backwards(OopClosureType* blk); |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
382 |
|
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
383 |
ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL) |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
384 |
ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL) |
4c24294029a9
6711316: Open source the Garbage-First garbage collector
ysr
parents:
382
diff
changeset
|
385 |
#endif |
1 | 386 |
|
387 |
void oop_iterate_header(OopClosure* blk); |
|
388 |
void oop_iterate_header(OopClosure* blk, MemRegion mr); |
|
389 |
||
390 |
// identity hash; returns the identity hash key (computes it if necessary) |
|
391 |
// NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a |
|
392 |
// safepoint if called on a biased object. Calling code must be aware of that. |
|
393 |
intptr_t identity_hash(); |
|
394 |
intptr_t slow_identity_hash(); |
|
395 |
||
396 |
// marks are forwarded to stack when object is locked |
|
397 |
bool has_displaced_mark() const; |
|
398 |
markOop displaced_mark() const; |
|
399 |
void set_displaced_mark(markOop m); |
|
400 |
||
401 |
// for code generation |
|
402 |
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
|
403 |
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
|
404 |
static int klass_gap_offset_in_bytes(); |
1 | 405 |
}; |