annotate src/share/vm/oops/oop.hpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank
author ysr
date Wed, 07 Sep 2011 13:55:42 -0700
parents c7f3d0b4570f
children b0efc7ee3b31
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2227
e5383553fd4e 7014851: Remove unused parallel compaction code
stefank
parents: 2226
diff changeset
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1123
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1123
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1123
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
25 #ifndef SHARE_VM_OOPS_OOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
26 #define SHARE_VM_OOPS_OOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
28 #include "memory/iterator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
29 #include "memory/memRegion.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
30 #include "memory/specialized_oop_closures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
31 #include "utilities/top.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
32
0
a61af66fc99e Initial load
duke
parents:
diff changeset
33 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // the format of Java objects so the fields can be accessed from C++.
a61af66fc99e Initial load
duke
parents:
diff changeset
35 // oopDesc is abstract.
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // (see oopHierarchy for complete oop class hierarchy)
a61af66fc99e Initial load
duke
parents:
diff changeset
37 //
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // no virtual functions allowed
a61af66fc99e Initial load
duke
parents:
diff changeset
39
a61af66fc99e Initial load
duke
parents:
diff changeset
40 // store into oop with store check
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
41 template <class T> void oop_store(T* p, oop v);
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
42 template <class T> void oop_store(volatile T* p, oop v);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
43
a61af66fc99e Initial load
duke
parents:
diff changeset
44 // store into oop without store check
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
45 template <class T> void oop_store_without_check(T* p, oop v);
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
46 template <class T> void oop_store_without_check(volatile T* p, oop v);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
47
a61af66fc99e Initial load
duke
parents:
diff changeset
48 extern bool always_do_update_barrier;
a61af66fc99e Initial load
duke
parents:
diff changeset
49
a61af66fc99e Initial load
duke
parents:
diff changeset
50 // Forward declarations.
a61af66fc99e Initial load
duke
parents:
diff changeset
51 class OopClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
52 class ScanClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
53 class FastScanClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
54 class FilteringClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
55 class BarrierSet;
a61af66fc99e Initial load
duke
parents:
diff changeset
56 class CMSIsAliveClosure;
a61af66fc99e Initial load
duke
parents:
diff changeset
57
a61af66fc99e Initial load
duke
parents:
diff changeset
58 class PSPromotionManager;
a61af66fc99e Initial load
duke
parents:
diff changeset
59 class ParCompactionManager;
a61af66fc99e Initial load
duke
parents:
diff changeset
60
a61af66fc99e Initial load
duke
parents:
diff changeset
61 class oopDesc {
a61af66fc99e Initial load
duke
parents:
diff changeset
62 friend class VMStructs;
a61af66fc99e Initial load
duke
parents:
diff changeset
63 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
64 volatile markOop _mark;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
65 union _metadata {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
66 wideKlassOop _klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
67 narrowOop _compressed_klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
68 } _metadata;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
69
a61af66fc99e Initial load
duke
parents:
diff changeset
70 // Fast access to barrier set. Must be initialized.
a61af66fc99e Initial load
duke
parents:
diff changeset
71 static BarrierSet* _bs;
a61af66fc99e Initial load
duke
parents:
diff changeset
72
a61af66fc99e Initial load
duke
parents:
diff changeset
73 public:
2226
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2177
diff changeset
74 enum ConcSafeType {
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2177
diff changeset
75 IsUnsafeConc = false,
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2177
diff changeset
76 IsSafeConc = true
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2177
diff changeset
77 };
c5a923563727 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 2177
diff changeset
78
0
a61af66fc99e Initial load
duke
parents:
diff changeset
79 markOop mark() const { return _mark; }
a61af66fc99e Initial load
duke
parents:
diff changeset
80 markOop* mark_addr() const { return (markOop*) &_mark; }
a61af66fc99e Initial load
duke
parents:
diff changeset
81
a61af66fc99e Initial load
duke
parents:
diff changeset
82 void set_mark(volatile markOop m) { _mark = m; }
a61af66fc99e Initial load
duke
parents:
diff changeset
83
a61af66fc99e Initial load
duke
parents:
diff changeset
84 void release_set_mark(markOop m);
a61af66fc99e Initial load
duke
parents:
diff changeset
85 markOop cas_set_mark(markOop new_mark, markOop old_mark);
a61af66fc99e Initial load
duke
parents:
diff changeset
86
a61af66fc99e Initial load
duke
parents:
diff changeset
87 // Used only to re-initialize the mark word (e.g., of promoted
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // objects during a GC) -- requires a valid klass pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
89 void init_mark();
a61af66fc99e Initial load
duke
parents:
diff changeset
90
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
91 klassOop klass() const;
167
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 135
diff changeset
92 klassOop klass_or_null() const volatile;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
93 oop* klass_addr();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
94 narrowOop* compressed_klass_addr();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
95
a61af66fc99e Initial load
duke
parents:
diff changeset
96 void set_klass(klassOop k);
167
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 135
diff changeset
97
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 135
diff changeset
98 // For klass field compression
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 135
diff changeset
99 int klass_gap() const;
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents: 135
diff changeset
100 void set_klass_gap(int z);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101 // For when the klass pointer is being used as a linked list "next" field.
a61af66fc99e Initial load
duke
parents:
diff changeset
102 void set_klass_to_list_ptr(oop k);
a61af66fc99e Initial load
duke
parents:
diff changeset
103
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
104 // size of object header, aligned to platform wordSize
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
105 static int header_size() { return sizeof(oopDesc)/HeapWordSize; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 Klass* blueprint() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
108
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // Returns whether this is an instance of k or an instance of a subclass of k
a61af66fc99e Initial load
duke
parents:
diff changeset
110 bool is_a(klassOop k) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
111
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // Returns the actual oop size of the object
a61af66fc99e Initial load
duke
parents:
diff changeset
113 int size();
a61af66fc99e Initial load
duke
parents:
diff changeset
114
a61af66fc99e Initial load
duke
parents:
diff changeset
115 // Sometimes (for complicated concurrency-related reasons), it is useful
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // to be able to figure out the size of an object knowing its klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
117 int size_given_klass(Klass* klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
118
a61af66fc99e Initial load
duke
parents:
diff changeset
119 // Some perm gen objects are not parseble immediately after
a61af66fc99e Initial load
duke
parents:
diff changeset
120 // installation of their klass pointer.
a61af66fc99e Initial load
duke
parents:
diff changeset
121 bool is_parsable();
a61af66fc99e Initial load
duke
parents:
diff changeset
122
518
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
123 // Some perm gen objects that have been allocated and initialized
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
124 // can be changed by the VM when not at a safe point (class rededfinition
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
125 // is an example). Such objects should not be examined by the
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
126 // concurrent processing of a garbage collector if is_conc_safe()
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
127 // returns false.
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
128 bool is_conc_safe();
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents: 356
diff changeset
129
0
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // type test operations (inlined in oop.inline.h)
a61af66fc99e Initial load
duke
parents:
diff changeset
131 bool is_instance() const;
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2227
diff changeset
132 bool is_instanceMirror() const;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
133 bool is_instanceRef() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
134 bool is_array() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 bool is_objArray() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
136 bool is_klass() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
137 bool is_thread() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
138 bool is_method() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
139 bool is_constMethod() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
140 bool is_methodData() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
141 bool is_constantPool() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
142 bool is_constantPoolCache() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
143 bool is_typeArray() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
144 bool is_javaArray() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
145 bool is_compiledICHolder() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
146
a61af66fc99e Initial load
duke
parents:
diff changeset
147 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // field addresses in oop
a61af66fc99e Initial load
duke
parents:
diff changeset
149 void* field_base(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
150
a61af66fc99e Initial load
duke
parents:
diff changeset
151 jbyte* byte_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
152 jchar* char_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
153 jboolean* bool_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
154 jint* int_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
155 jshort* short_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
156 jlong* long_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
157 jfloat* float_field_addr(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
158 jdouble* double_field_addr(int offset) const;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
159 address* address_field_addr(int offset) const;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
160
a61af66fc99e Initial load
duke
parents:
diff changeset
161 public:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
162 // Need this as public for garbage collection.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
163 template <class T> T* obj_field_addr(int offset) const;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
164
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
165 static bool is_null(oop obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
166 static bool is_null(narrowOop obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
167
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
168 // Decode an oop pointer from a narrowOop if compressed.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
169 // These are overloaded for oop and narrowOop as are the other functions
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
170 // below so that they can be called in template functions.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
171 static oop decode_heap_oop_not_null(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
172 static oop decode_heap_oop_not_null(narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
173 static oop decode_heap_oop(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
174 static oop decode_heap_oop(narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
175
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
176 // Encode an oop pointer to a narrow oop. The or_null versions accept
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
177 // null oop pointer, others do not in order to eliminate the
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
178 // null checking branches.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
179 static narrowOop encode_heap_oop_not_null(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
180 static narrowOop encode_heap_oop(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
181
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
182 // Load an oop out of the Java heap
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
183 static narrowOop load_heap_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
184 static oop load_heap_oop(oop* p);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
185
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
186 // Load an oop out of Java heap and decode it to an uncompressed oop.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
187 static oop load_decode_heap_oop_not_null(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
188 static oop load_decode_heap_oop_not_null(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
189 static oop load_decode_heap_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
190 static oop load_decode_heap_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
191
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
192 // Store an oop into the heap.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
193 static void store_heap_oop(narrowOop* p, narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
194 static void store_heap_oop(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
195
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
196 // Encode oop if UseCompressedOops and store into the heap.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
197 static void encode_store_heap_oop_not_null(narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
198 static void encode_store_heap_oop_not_null(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
199 static void encode_store_heap_oop(narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
200 static void encode_store_heap_oop(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
201
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
202 static void release_store_heap_oop(volatile narrowOop* p, narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
203 static void release_store_heap_oop(volatile oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
204
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
205 static void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
206 static void release_encode_store_heap_oop_not_null(volatile oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
207 static void release_encode_store_heap_oop(volatile narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
208 static void release_encode_store_heap_oop(volatile oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
209
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
210 static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
211 static oop atomic_compare_exchange_oop(oop exchange_value,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
212 volatile HeapWord *dest,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
213 oop compare_value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
214
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
215 // Access to fields in a instanceOop through these methods.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
216 oop obj_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
217 void obj_field_put(int offset, oop value);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
218 void obj_field_raw_put(int offset, oop value);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220 jbyte byte_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
221 void byte_field_put(int offset, jbyte contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 jchar char_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
224 void char_field_put(int offset, jchar contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 jboolean bool_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
227 void bool_field_put(int offset, jboolean contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 jint int_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
230 void int_field_put(int offset, jint contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
231
a61af66fc99e Initial load
duke
parents:
diff changeset
232 jshort short_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
233 void short_field_put(int offset, jshort contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
234
a61af66fc99e Initial load
duke
parents:
diff changeset
235 jlong long_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
236 void long_field_put(int offset, jlong contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
237
a61af66fc99e Initial load
duke
parents:
diff changeset
238 jfloat float_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
239 void float_field_put(int offset, jfloat contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
240
a61af66fc99e Initial load
duke
parents:
diff changeset
241 jdouble double_field(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
242 void double_field_put(int offset, jdouble contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
243
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
244 address address_field(int offset) const;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
245 void address_field_put(int offset, address contents);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
246
0
a61af66fc99e Initial load
duke
parents:
diff changeset
247 oop obj_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
248 void release_obj_field_put(int offset, oop value);
a61af66fc99e Initial load
duke
parents:
diff changeset
249
a61af66fc99e Initial load
duke
parents:
diff changeset
250 jbyte byte_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
251 void release_byte_field_put(int offset, jbyte contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
252
a61af66fc99e Initial load
duke
parents:
diff changeset
253 jchar char_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
254 void release_char_field_put(int offset, jchar contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
255
a61af66fc99e Initial load
duke
parents:
diff changeset
256 jboolean bool_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
257 void release_bool_field_put(int offset, jboolean contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
258
a61af66fc99e Initial load
duke
parents:
diff changeset
259 jint int_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
260 void release_int_field_put(int offset, jint contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
261
a61af66fc99e Initial load
duke
parents:
diff changeset
262 jshort short_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
263 void release_short_field_put(int offset, jshort contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
264
a61af66fc99e Initial load
duke
parents:
diff changeset
265 jlong long_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
266 void release_long_field_put(int offset, jlong contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
267
a61af66fc99e Initial load
duke
parents:
diff changeset
268 jfloat float_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
269 void release_float_field_put(int offset, jfloat contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
270
a61af66fc99e Initial load
duke
parents:
diff changeset
271 jdouble double_field_acquire(int offset) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
272 void release_double_field_put(int offset, jdouble contents);
a61af66fc99e Initial load
duke
parents:
diff changeset
273
710
e5b0439ef4ae 6655638: dynamic languages need method handles
jrose
parents: 579
diff changeset
274 address address_field_acquire(int offset) const;
e5b0439ef4ae 6655638: dynamic languages need method handles
jrose
parents: 579
diff changeset
275 void release_address_field_put(int offset, address contents);
e5b0439ef4ae 6655638: dynamic languages need method handles
jrose
parents: 579
diff changeset
276
0
a61af66fc99e Initial load
duke
parents:
diff changeset
277 // printing functions for VM debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
278 void print_on(outputStream* st) const; // First level print
a61af66fc99e Initial load
duke
parents:
diff changeset
279 void print_value_on(outputStream* st) const; // Second level print.
a61af66fc99e Initial load
duke
parents:
diff changeset
280 void print_address_on(outputStream* st) const; // Address printing
a61af66fc99e Initial load
duke
parents:
diff changeset
281
a61af66fc99e Initial load
duke
parents:
diff changeset
282 // printing on default output stream
a61af66fc99e Initial load
duke
parents:
diff changeset
283 void print();
a61af66fc99e Initial load
duke
parents:
diff changeset
284 void print_value();
a61af66fc99e Initial load
duke
parents:
diff changeset
285 void print_address();
a61af66fc99e Initial load
duke
parents:
diff changeset
286
a61af66fc99e Initial load
duke
parents:
diff changeset
287 // return the print strings
a61af66fc99e Initial load
duke
parents:
diff changeset
288 char* print_string();
a61af66fc99e Initial load
duke
parents:
diff changeset
289 char* print_value_string();
a61af66fc99e Initial load
duke
parents:
diff changeset
290
a61af66fc99e Initial load
duke
parents:
diff changeset
291 // verification operations
a61af66fc99e Initial load
duke
parents:
diff changeset
292 void verify_on(outputStream* st);
a61af66fc99e Initial load
duke
parents:
diff changeset
293 void verify();
a61af66fc99e Initial load
duke
parents:
diff changeset
294 void verify_old_oop(oop* p, bool allow_dirty);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
295 void verify_old_oop(narrowOop* p, bool allow_dirty);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
296
a61af66fc99e Initial load
duke
parents:
diff changeset
297 // tells whether this oop is partially constructed (gc during class loading)
a61af66fc99e Initial load
duke
parents:
diff changeset
298 bool partially_loaded();
a61af66fc99e Initial load
duke
parents:
diff changeset
299 void set_partially_loaded();
a61af66fc99e Initial load
duke
parents:
diff changeset
300
a61af66fc99e Initial load
duke
parents:
diff changeset
301 // locking operations
a61af66fc99e Initial load
duke
parents:
diff changeset
302 bool is_locked() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
303 bool is_unlocked() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
304 bool has_bias_pattern() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
305
a61af66fc99e Initial load
duke
parents:
diff changeset
306 // asserts
a61af66fc99e Initial load
duke
parents:
diff changeset
307 bool is_oop(bool ignore_mark_word = false) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
308 bool is_oop_or_null(bool ignore_mark_word = false) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
309 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
310 bool is_unlocked_oop() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
311 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
312
a61af66fc99e Initial load
duke
parents:
diff changeset
313 // garbage collection
a61af66fc99e Initial load
duke
parents:
diff changeset
314 bool is_gc_marked() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
315 // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
316 // reference field in "this".
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
317 void follow_contents(void);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
318 void follow_header(void);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
319
a61af66fc99e Initial load
duke
parents:
diff changeset
320 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
321 // Parallel Scavenge
a61af66fc99e Initial load
duke
parents:
diff changeset
322 void push_contents(PSPromotionManager* pm);
a61af66fc99e Initial load
duke
parents:
diff changeset
323
a61af66fc99e Initial load
duke
parents:
diff changeset
324 // Parallel Old
a61af66fc99e Initial load
duke
parents:
diff changeset
325 void update_contents(ParCompactionManager* cm);
a61af66fc99e Initial load
duke
parents:
diff changeset
326
a61af66fc99e Initial load
duke
parents:
diff changeset
327 void follow_contents(ParCompactionManager* cm);
a61af66fc99e Initial load
duke
parents:
diff changeset
328 void follow_header(ParCompactionManager* cm);
a61af66fc99e Initial load
duke
parents:
diff changeset
329 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
330
a61af66fc99e Initial load
duke
parents:
diff changeset
331 bool is_perm() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
332 bool is_perm_or_null() const;
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 710
diff changeset
333 bool is_scavengable() const;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
334 bool is_shared() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
335 bool is_shared_readonly() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
336 bool is_shared_readwrite() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
337
a61af66fc99e Initial load
duke
parents:
diff changeset
338 // Forward pointer operations for scavenge
a61af66fc99e Initial load
duke
parents:
diff changeset
339 bool is_forwarded() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
340
a61af66fc99e Initial load
duke
parents:
diff changeset
341 void forward_to(oop p);
a61af66fc99e Initial load
duke
parents:
diff changeset
342 bool cas_forward_to(oop p, markOop compare);
a61af66fc99e Initial load
duke
parents:
diff changeset
343
a61af66fc99e Initial load
duke
parents:
diff changeset
344 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
345 // Like "forward_to", but inserts the forwarding pointer atomically.
a61af66fc99e Initial load
duke
parents:
diff changeset
346 // Exactly one thread succeeds in inserting the forwarding pointer, and
a61af66fc99e Initial load
duke
parents:
diff changeset
347 // this call returns "NULL" for that thread; any other thread has the
a61af66fc99e Initial load
duke
parents:
diff changeset
348 // value of the forwarding pointer returned and does not modify "this".
a61af66fc99e Initial load
duke
parents:
diff changeset
349 oop forward_to_atomic(oop p);
a61af66fc99e Initial load
duke
parents:
diff changeset
350 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
351
a61af66fc99e Initial load
duke
parents:
diff changeset
352 oop forwardee() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
353
a61af66fc99e Initial load
duke
parents:
diff changeset
354 // Age of object during scavenge
a61af66fc99e Initial load
duke
parents:
diff changeset
355 int age() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
356 void incr_age();
a61af66fc99e Initial load
duke
parents:
diff changeset
357
a61af66fc99e Initial load
duke
parents:
diff changeset
358 // Adjust all pointers in this object to point at it's forwarded location and
a61af66fc99e Initial load
duke
parents:
diff changeset
359 // return the size of this oop. This is used by the MarkSweep collector.
a61af66fc99e Initial load
duke
parents:
diff changeset
360 int adjust_pointers();
a61af66fc99e Initial load
duke
parents:
diff changeset
361 void adjust_header();
a61af66fc99e Initial load
duke
parents:
diff changeset
362
a61af66fc99e Initial load
duke
parents:
diff changeset
363 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
364 // Parallel old
a61af66fc99e Initial load
duke
parents:
diff changeset
365 void update_header();
a61af66fc99e Initial load
duke
parents:
diff changeset
366 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
367
a61af66fc99e Initial load
duke
parents:
diff changeset
368 // mark-sweep support
a61af66fc99e Initial load
duke
parents:
diff changeset
369 void follow_body(int begin, int end);
a61af66fc99e Initial load
duke
parents:
diff changeset
370
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // Fast access to barrier set
a61af66fc99e Initial load
duke
parents:
diff changeset
372 static BarrierSet* bs() { return _bs; }
a61af66fc99e Initial load
duke
parents:
diff changeset
373 static void set_bs(BarrierSet* bs) { _bs = bs; }
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375 // iterators, returns size of object
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
376 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
377 int oop_iterate(OopClosureType* blk); \
a61af66fc99e Initial load
duke
parents:
diff changeset
378 int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr.
a61af66fc99e Initial load
duke
parents:
diff changeset
379
a61af66fc99e Initial load
duke
parents:
diff changeset
380 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
381 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
382
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
383 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
384
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
385 #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
386 int oop_iterate_backwards(OopClosureType* blk);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
387
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
388 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
389 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 135
diff changeset
390 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
391
a61af66fc99e Initial load
duke
parents:
diff changeset
392 void oop_iterate_header(OopClosure* blk);
a61af66fc99e Initial load
duke
parents:
diff changeset
393 void oop_iterate_header(OopClosure* blk, MemRegion mr);
a61af66fc99e Initial load
duke
parents:
diff changeset
394
a61af66fc99e Initial load
duke
parents:
diff changeset
395 // identity hash; returns the identity hash key (computes it if necessary)
a61af66fc99e Initial load
duke
parents:
diff changeset
396 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a
a61af66fc99e Initial load
duke
parents:
diff changeset
397 // safepoint if called on a biased object. Calling code must be aware of that.
a61af66fc99e Initial load
duke
parents:
diff changeset
398 intptr_t identity_hash();
a61af66fc99e Initial load
duke
parents:
diff changeset
399 intptr_t slow_identity_hash();
a61af66fc99e Initial load
duke
parents:
diff changeset
400
a61af66fc99e Initial load
duke
parents:
diff changeset
401 // marks are forwarded to stack when object is locked
a61af66fc99e Initial load
duke
parents:
diff changeset
402 bool has_displaced_mark() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
403 markOop displaced_mark() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
404 void set_displaced_mark(markOop m);
a61af66fc99e Initial load
duke
parents:
diff changeset
405
a61af66fc99e Initial load
duke
parents:
diff changeset
406 // for code generation
a61af66fc99e Initial load
duke
parents:
diff changeset
407 static int mark_offset_in_bytes() { return offset_of(oopDesc, _mark); }
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
408 static int klass_offset_in_bytes() { return offset_of(oopDesc, _metadata._klass); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
409 static int klass_gap_offset_in_bytes();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
410 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
411
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1706
diff changeset
412 #endif // SHARE_VM_OOPS_OOP_HPP