Mercurial > hg > truffle
annotate src/share/vm/oops/markOop.hpp @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
| author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
|---|---|
| date | Mon, 02 Jan 2012 14:16:08 -0800 |
| parents | 1d1603768966 |
| children | da91efe96a93 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1546
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1546
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:
1546
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_MARKOOP_HPP |
| 26 #define SHARE_VM_OOPS_MARKOOP_HPP | |
| 27 | |
| 28 #include "oops/oop.hpp" | |
| 29 | |
| 0 | 30 // The markOop describes the header of an object. |
| 31 // | |
| 32 // Note that the mark is not a real oop but just a word. | |
| 33 // It is placed in the oop hierarchy for historical reasons. | |
| 34 // | |
|
1546
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
35 // Bit-format of an object header (most significant first, big endian layout below): |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
36 // |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
37 // 32 bits: |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
38 // -------- |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
39 // hash:25 ------------>| age:4 biased_lock:1 lock:2 (normal object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
40 // JavaThread*:23 epoch:2 age:4 biased_lock:1 lock:2 (biased object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
41 // size:32 ------------------------------------------>| (CMS free block) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
42 // PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object) |
| 0 | 43 // |
|
1546
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
44 // 64 bits: |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
45 // -------- |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
46 // unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
47 // JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
48 // PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
49 // size:64 ----------------------------------------------------->| (CMS free block) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
50 // |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
51 // unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
52 // JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
53 // narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
54 // unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block) |
| 0 | 55 // |
| 56 // - hash contains the identity hash value: largest value is | |
| 57 // 31 bits, see os::random(). Also, 64-bit vm's require | |
| 58 // a hash value no bigger than 32 bits because they will not | |
| 59 // properly generate a mask larger than that: see library_call.cpp | |
| 60 // and c1_CodePatterns_sparc.cpp. | |
| 61 // | |
| 62 // - the biased lock pattern is used to bias a lock toward a given | |
| 63 // thread. When this pattern is set in the low three bits, the lock | |
| 64 // is either biased toward a given thread or "anonymously" biased, | |
| 65 // indicating that it is possible for it to be biased. When the | |
| 66 // lock is biased toward a given thread, locking and unlocking can | |
| 67 // be performed by that thread without using atomic operations. | |
| 68 // When a lock's bias is revoked, it reverts back to the normal | |
| 69 // locking scheme described below. | |
| 70 // | |
| 71 // Note that we are overloading the meaning of the "unlocked" state | |
| 72 // of the header. Because we steal a bit from the age we can | |
| 73 // guarantee that the bias pattern will never be seen for a truly | |
| 74 // unlocked object. | |
| 75 // | |
| 76 // Note also that the biased state contains the age bits normally | |
| 77 // contained in the object header. Large increases in scavenge | |
| 78 // times were seen when these bits were absent and an arbitrary age | |
| 79 // assigned to all biased objects, because they tended to consume a | |
| 80 // significant fraction of the eden semispaces and were not | |
| 81 // promoted promptly, causing an increase in the amount of copying | |
| 82 // performed. The runtime system aligns all JavaThread* pointers to | |
|
1546
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
83 // a very large value (currently 128 bytes (32bVM) or 256 bytes (64bVM)) |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
84 // to make room for the age bits & the epoch bits (used in support of |
|
a00b51b2dda4
6948539: CMS+UseCompressedOops: placement of cms_free bit interferes with promoted object link
ysr
parents:
356
diff
changeset
|
85 // biased locking), and for the CMS "freeness" bit in the 64bVM (+COOPs). |
| 0 | 86 // |
| 87 // [JavaThread* | epoch | age | 1 | 01] lock is biased toward given thread | |
| 88 // [0 | epoch | age | 1 | 01] lock is anonymously biased | |
| 89 // | |
| 90 // - the two lock bits are used to describe three states: locked/unlocked and monitor. | |
| 91 // | |
| 92 // [ptr | 00] locked ptr points to real header on stack | |
| 93 // [header | 0 | 01] unlocked regular object header | |
| 94 // [ptr | 10] monitor inflated lock (header is wapped out) | |
| 95 // [ptr | 11] marked used by markSweep to mark an object | |
| 96 // not valid at any other time | |
| 97 // | |
| 98 // We assume that stack/thread pointers have the lowest two bits cleared. | |
| 99 | |
| 100 class BasicLock; | |
| 101 class ObjectMonitor; | |
| 102 class JavaThread; | |
| 103 | |
| 104 class markOopDesc: public oopDesc { | |
| 105 private: | |
| 106 // Conversion | |
| 107 uintptr_t value() const { return (uintptr_t) this; } | |
| 108 | |
| 109 public: | |
| 110 // Constants | |
| 111 enum { age_bits = 4, | |
| 112 lock_bits = 2, | |
| 113 biased_lock_bits = 1, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
48
diff
changeset
|
114 max_hash_bits = BitsPerWord - age_bits - lock_bits - biased_lock_bits, |
| 0 | 115 hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits, |
| 187 | 116 cms_bits = LP64_ONLY(1) NOT_LP64(0), |
| 0 | 117 epoch_bits = 2 |
| 118 }; | |
| 119 | |
| 120 // The biased locking code currently requires that the age bits be | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
121 // contiguous to the lock bits. |
| 0 | 122 enum { lock_shift = 0, |
| 123 biased_lock_shift = lock_bits, | |
| 124 age_shift = lock_bits + biased_lock_bits, | |
| 187 | 125 cms_shift = age_shift + age_bits, |
| 126 hash_shift = cms_shift + cms_bits, | |
| 0 | 127 epoch_shift = hash_shift |
| 128 }; | |
| 129 | |
| 130 enum { lock_mask = right_n_bits(lock_bits), | |
| 131 lock_mask_in_place = lock_mask << lock_shift, | |
| 132 biased_lock_mask = right_n_bits(lock_bits + biased_lock_bits), | |
| 133 biased_lock_mask_in_place= biased_lock_mask << lock_shift, | |
| 134 biased_lock_bit_in_place = 1 << biased_lock_shift, | |
| 135 age_mask = right_n_bits(age_bits), | |
| 136 age_mask_in_place = age_mask << age_shift, | |
| 137 epoch_mask = right_n_bits(epoch_bits), | |
| 187 | 138 epoch_mask_in_place = epoch_mask << epoch_shift, |
| 139 cms_mask = right_n_bits(cms_bits), | |
| 140 cms_mask_in_place = cms_mask << cms_shift | |
| 0 | 141 #ifndef _WIN64 |
| 142 ,hash_mask = right_n_bits(hash_bits), | |
| 143 hash_mask_in_place = (address_word)hash_mask << hash_shift | |
| 144 #endif | |
| 145 }; | |
| 146 | |
| 147 // Alignment of JavaThread pointers encoded in object header required by biased locking | |
| 148 enum { biased_lock_alignment = 2 << (epoch_shift + epoch_bits) | |
| 149 }; | |
| 150 | |
| 151 #ifdef _WIN64 | |
| 152 // These values are too big for Win64 | |
| 153 const static uintptr_t hash_mask = right_n_bits(hash_bits); | |
| 154 const static uintptr_t hash_mask_in_place = | |
| 155 (address_word)hash_mask << hash_shift; | |
| 156 #endif | |
| 157 | |
| 158 enum { locked_value = 0, | |
| 159 unlocked_value = 1, | |
| 160 monitor_value = 2, | |
| 161 marked_value = 3, | |
| 162 biased_lock_pattern = 5 | |
| 163 }; | |
| 164 | |
| 165 enum { no_hash = 0 }; // no hash value assigned | |
| 166 | |
| 167 enum { no_hash_in_place = (address_word)no_hash << hash_shift, | |
| 168 no_lock_in_place = unlocked_value | |
| 169 }; | |
| 170 | |
| 171 enum { max_age = age_mask }; | |
| 172 | |
| 173 enum { max_bias_epoch = epoch_mask }; | |
| 174 | |
| 175 // Biased Locking accessors. | |
| 176 // These must be checked by all code which calls into the | |
| 177 // ObjectSynchronizer and other code. The biasing is not understood | |
| 178 // by the lower-level CAS-based locking code, although the runtime | |
| 179 // fixes up biased locks to be compatible with it when a bias is | |
| 180 // revoked. | |
| 181 bool has_bias_pattern() const { | |
| 182 return (mask_bits(value(), biased_lock_mask_in_place) == biased_lock_pattern); | |
| 183 } | |
| 184 JavaThread* biased_locker() const { | |
| 185 assert(has_bias_pattern(), "should not call this otherwise"); | |
| 186 return (JavaThread*) ((intptr_t) (mask_bits(value(), ~(biased_lock_mask_in_place | age_mask_in_place | epoch_mask_in_place)))); | |
| 187 } | |
| 188 // Indicates that the mark has the bias bit set but that it has not | |
| 189 // yet been biased toward a particular thread | |
| 190 bool is_biased_anonymously() const { | |
| 191 return (has_bias_pattern() && (biased_locker() == NULL)); | |
| 192 } | |
| 193 // Indicates epoch in which this bias was acquired. If the epoch | |
| 194 // changes due to too many bias revocations occurring, the biases | |
| 195 // from the previous epochs are all considered invalid. | |
| 196 int bias_epoch() const { | |
| 197 assert(has_bias_pattern(), "should not call this otherwise"); | |
| 198 return (mask_bits(value(), epoch_mask_in_place) >> epoch_shift); | |
| 199 } | |
| 200 markOop set_bias_epoch(int epoch) { | |
| 201 assert(has_bias_pattern(), "should not call this otherwise"); | |
| 202 assert((epoch & (~epoch_mask)) == 0, "epoch overflow"); | |
| 203 return markOop(mask_bits(value(), ~epoch_mask_in_place) | (epoch << epoch_shift)); | |
| 204 } | |
| 205 markOop incr_bias_epoch() { | |
| 206 return set_bias_epoch((1 + bias_epoch()) & epoch_mask); | |
| 207 } | |
| 208 // Prototype mark for initialization | |
| 209 static markOop biased_locking_prototype() { | |
| 210 return markOop( biased_lock_pattern ); | |
| 211 } | |
| 212 | |
| 213 // lock accessors (note that these assume lock_shift == 0) | |
| 214 bool is_locked() const { | |
| 215 return (mask_bits(value(), lock_mask_in_place) != unlocked_value); | |
| 216 } | |
| 217 bool is_unlocked() const { | |
| 218 return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value); | |
| 219 } | |
| 220 bool is_marked() const { | |
| 221 return (mask_bits(value(), lock_mask_in_place) == marked_value); | |
| 222 } | |
| 223 bool is_neutral() const { return (mask_bits(value(), biased_lock_mask_in_place) == unlocked_value); } | |
| 224 | |
| 225 // Special temporary state of the markOop while being inflated. | |
| 226 // Code that looks at mark outside a lock need to take this into account. | |
| 227 bool is_being_inflated() const { return (value() == 0); } | |
| 228 | |
| 229 // Distinguished markword value - used when inflating over | |
| 230 // an existing stacklock. 0 indicates the markword is "BUSY". | |
| 231 // Lockword mutators that use a LD...CAS idiom should always | |
| 232 // check for and avoid overwriting a 0 value installed by some | |
| 233 // other thread. (They should spin or block instead. The 0 value | |
| 234 // is transient and *should* be short-lived). | |
| 235 static markOop INFLATING() { return (markOop) 0; } // inflate-in-progress | |
| 236 | |
| 237 // Should this header be preserved during GC? | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
238 inline bool must_be_preserved(oop obj_containing_mark) const; |
| 0 | 239 inline bool must_be_preserved_with_bias(oop obj_containing_mark) const; |
| 240 | |
| 241 // Should this header (including its age bits) be preserved in the | |
| 242 // case of a promotion failure during scavenge? | |
| 243 // Note that we special case this situation. We want to avoid | |
| 244 // calling BiasedLocking::preserve_marks()/restore_marks() (which | |
| 245 // decrease the number of mark words that need to be preserved | |
| 246 // during GC) during each scavenge. During scavenges in which there | |
| 247 // is no promotion failure, we actually don't need to call the above | |
| 248 // routines at all, since we don't mutate and re-initialize the | |
| 249 // marks of promoted objects using init_mark(). However, during | |
| 250 // scavenges which result in promotion failure, we do re-initialize | |
| 251 // the mark words of objects, meaning that we should have called | |
| 252 // these mark word preservation routines. Currently there's no good | |
| 253 // place in which to call them in any of the scavengers (although | |
| 254 // guarded by appropriate locks we could make one), but the | |
| 255 // observation is that promotion failures are quite rare and | |
| 256 // reducing the number of mark words preserved during them isn't a | |
| 257 // high priority. | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
258 inline bool must_be_preserved_for_promotion_failure(oop obj_containing_mark) const; |
| 0 | 259 inline bool must_be_preserved_with_bias_for_promotion_failure(oop obj_containing_mark) const; |
| 260 | |
| 261 // Should this header be preserved during a scavenge where CMS is | |
| 262 // the old generation? | |
| 263 // (This is basically the same body as must_be_preserved_for_promotion_failure(), | |
| 264 // but takes the klassOop as argument instead) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
265 inline bool must_be_preserved_for_cms_scavenge(klassOop klass_of_obj_containing_mark) const; |
| 0 | 266 inline bool must_be_preserved_with_bias_for_cms_scavenge(klassOop klass_of_obj_containing_mark) const; |
| 267 | |
| 268 // WARNING: The following routines are used EXCLUSIVELY by | |
| 269 // synchronization functions. They are not really gc safe. | |
| 270 // They must get updated if markOop layout get changed. | |
| 271 markOop set_unlocked() const { | |
| 272 return markOop(value() | unlocked_value); | |
| 273 } | |
| 274 bool has_locker() const { | |
| 275 return ((value() & lock_mask_in_place) == locked_value); | |
| 276 } | |
| 277 BasicLock* locker() const { | |
| 278 assert(has_locker(), "check"); | |
| 279 return (BasicLock*) value(); | |
| 280 } | |
| 281 bool has_monitor() const { | |
| 282 return ((value() & monitor_value) != 0); | |
| 283 } | |
| 284 ObjectMonitor* monitor() const { | |
| 285 assert(has_monitor(), "check"); | |
| 286 // Use xor instead of &~ to provide one extra tag-bit check. | |
| 287 return (ObjectMonitor*) (value() ^ monitor_value); | |
| 288 } | |
| 289 bool has_displaced_mark_helper() const { | |
| 290 return ((value() & unlocked_value) == 0); | |
| 291 } | |
| 292 markOop displaced_mark_helper() const { | |
| 293 assert(has_displaced_mark_helper(), "check"); | |
| 294 intptr_t ptr = (value() & ~monitor_value); | |
| 295 return *(markOop*)ptr; | |
| 296 } | |
| 297 void set_displaced_mark_helper(markOop m) const { | |
| 298 assert(has_displaced_mark_helper(), "check"); | |
| 299 intptr_t ptr = (value() & ~monitor_value); | |
| 300 *(markOop*)ptr = m; | |
| 301 } | |
| 302 markOop copy_set_hash(intptr_t hash) const { | |
| 303 intptr_t tmp = value() & (~hash_mask_in_place); | |
| 304 tmp |= ((hash & hash_mask) << hash_shift); | |
| 305 return (markOop)tmp; | |
| 306 } | |
| 307 // it is only used to be stored into BasicLock as the | |
| 308 // indicator that the lock is using heavyweight monitor | |
| 309 static markOop unused_mark() { | |
| 310 return (markOop) marked_value; | |
| 311 } | |
| 312 // the following two functions create the markOop to be | |
| 313 // stored into object header, it encodes monitor info | |
| 314 static markOop encode(BasicLock* lock) { | |
| 315 return (markOop) lock; | |
| 316 } | |
| 317 static markOop encode(ObjectMonitor* monitor) { | |
| 318 intptr_t tmp = (intptr_t) monitor; | |
| 319 return (markOop) (tmp | monitor_value); | |
| 320 } | |
| 321 static markOop encode(JavaThread* thread, int age, int bias_epoch) { | |
| 322 intptr_t tmp = (intptr_t) thread; | |
| 323 assert(UseBiasedLocking && ((tmp & (epoch_mask_in_place | age_mask_in_place | biased_lock_mask_in_place)) == 0), "misaligned JavaThread pointer"); | |
| 324 assert(age <= max_age, "age too large"); | |
| 325 assert(bias_epoch <= max_bias_epoch, "bias epoch too large"); | |
| 326 return (markOop) (tmp | (bias_epoch << epoch_shift) | (age << age_shift) | biased_lock_pattern); | |
| 327 } | |
| 328 | |
| 329 // used to encode pointers during GC | |
| 330 markOop clear_lock_bits() { return markOop(value() & ~lock_mask_in_place); } | |
| 331 | |
| 332 // age operations | |
| 333 markOop set_marked() { return markOop((value() & ~lock_mask_in_place) | marked_value); } | |
| 334 | |
| 335 int age() const { return mask_bits(value() >> age_shift, age_mask); } | |
| 336 markOop set_age(int v) const { | |
| 337 assert((v & ~age_mask) == 0, "shouldn't overflow age field"); | |
| 338 return markOop((value() & ~age_mask_in_place) | (((intptr_t)v & age_mask) << age_shift)); | |
| 339 } | |
| 340 markOop incr_age() const { return age() == max_age ? markOop(this) : set_age(age() + 1); } | |
| 341 | |
| 342 // hash operations | |
| 343 intptr_t hash() const { | |
| 344 return mask_bits(value() >> hash_shift, hash_mask); | |
| 345 } | |
| 346 | |
| 347 bool has_no_hash() const { | |
| 348 return hash() == no_hash; | |
| 349 } | |
| 350 | |
| 351 // Prototype mark for initialization | |
| 352 static markOop prototype() { | |
| 353 return markOop( no_hash_in_place | no_lock_in_place ); | |
| 354 } | |
| 355 | |
| 356 // Helper function for restoration of unmarked mark oops during GC | |
| 357 static inline markOop prototype_for_object(oop obj); | |
| 358 | |
| 359 // Debugging | |
| 360 void print_on(outputStream* st) const; | |
| 361 | |
| 362 // Prepare address of oop for placement into mark | |
| 363 inline static markOop encode_pointer_as_mark(void* p) { return markOop(p)->set_marked(); } | |
| 364 | |
| 365 // Recover address of oop from encoded form used in mark | |
| 366 inline void* decode_pointer() { if (UseBiasedLocking && has_bias_pattern()) return NULL; return clear_lock_bits(); } | |
|
48
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
367 |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
368 // see the definition in markOop.cpp for the gory details |
|
d8b3ef7ee3e5
6599425: 4/3 OopMapCache::lookup() can cause later crash or assert() failure
dcubed
parents:
0
diff
changeset
|
369 bool should_not_be_cached() const; |
| 187 | 370 |
| 371 // These markOops indicate cms free chunk blocks and not objects. | |
| 372 // In 64 bit, the markOop is set to distinguish them from oops. | |
| 373 // These are defined in 32 bit mode for vmStructs. | |
| 374 const static uintptr_t cms_free_chunk_pattern = 0x1; | |
| 375 | |
| 376 // Constants for the size field. | |
| 377 enum { size_shift = cms_shift + cms_bits, | |
| 378 size_bits = 35 // need for compressed oops 32G | |
| 379 }; | |
| 380 // These values are too big for Win64 | |
| 381 const static uintptr_t size_mask = LP64_ONLY(right_n_bits(size_bits)) | |
| 382 NOT_LP64(0); | |
| 383 const static uintptr_t size_mask_in_place = | |
| 384 (address_word)size_mask << size_shift; | |
| 385 | |
| 386 #ifdef _LP64 | |
| 387 static markOop cms_free_prototype() { | |
| 388 return markOop(((intptr_t)prototype() & ~cms_mask_in_place) | | |
| 389 ((cms_free_chunk_pattern & cms_mask) << cms_shift)); | |
| 390 } | |
| 391 uintptr_t cms_encoding() const { | |
| 392 return mask_bits(value() >> cms_shift, cms_mask); | |
| 393 } | |
| 394 bool is_cms_free_chunk() const { | |
| 395 return is_neutral() && | |
| 396 (cms_encoding() & cms_free_chunk_pattern) == cms_free_chunk_pattern; | |
| 397 } | |
| 398 | |
| 399 size_t get_size() const { return (size_t)(value() >> size_shift); } | |
| 400 static markOop set_size_and_free(size_t size) { | |
| 401 assert((size & ~size_mask) == 0, "shouldn't overflow size field"); | |
| 402 return markOop(((intptr_t)cms_free_prototype() & ~size_mask_in_place) | | |
| 403 (((intptr_t)size & size_mask) << size_shift)); | |
| 404 } | |
| 405 #endif // _LP64 | |
| 0 | 406 }; |
| 1972 | 407 |
| 408 #endif // SHARE_VM_OOPS_MARKOOP_HPP |