1 /* 2 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_OOPS_MARKWORD_HPP 26 #define SHARE_OOPS_MARKWORD_HPP 27 28 #include "metaprogramming/primitiveConversions.hpp" 29 #include "oops/compressedKlass.hpp" 30 #include "oops/oopsHierarchy.hpp" 31 #include "runtime/globals.hpp" 32 #include "utilities/globalDefinitions.hpp" 33 34 #include <type_traits> 35 36 // The markWord describes the header of an object. 37 // 38 // Bit-format of an object header (most significant first, big endian layout below): 39 // 40 // 32 bits: 41 // -------- 42 // hash:25 ------------>| age:4 self-fwd:1 lock:2 (normal object) 43 // 44 // 64 bits: 45 // -------- 46 // unused:25 hash:31 -->| unused_gap:1 age:4 self-fwd:1 lock:2 (normal object) 47 // 48 // 64 bits (with compact headers): 49 // ------------------------------- 50 // nklass:32 hash:25 -->| unused_gap:1 age:4 self-fwded:1 lock:2 (normal object) 51 // 52 // - hash contains the identity hash value: largest value is 53 // 31 bits, see os::random(). Also, 64-bit vm's require 54 // a hash value no bigger than 32 bits because they will not 55 // properly generate a mask larger than that: see library_call.cpp 56 // 57 // - the two lock bits are used to describe three states: locked/unlocked and monitor. 58 // 59 // [ptr | 00] locked ptr points to real header on stack (stack-locking in use) 60 // [header | 00] locked locked regular object header (fast-locking in use) 61 // [header | 01] unlocked regular object header 62 // [ptr | 10] monitor inflated lock (header is swapped out) 63 // [ptr | 11] marked used to mark an object 64 // [0 ............ 0| 00] inflating inflation in progress (stack-locking in use) 65 // 66 // We assume that stack/thread pointers have the lowest two bits cleared. 67 // 68 // - INFLATING() is a distinguished markword value of all zeros that is 69 // used when inflating an existing stack-lock into an ObjectMonitor. 70 // See below for is_being_inflated() and INFLATING(). 71 72 class BasicLock; 73 class ObjectMonitor; 74 class JavaThread; 75 class outputStream; 76 77 class markWord { 78 private: 79 uintptr_t _value; 80 81 public: 82 explicit markWord(uintptr_t value) : _value(value) {} 83 84 markWord() = default; // Doesn't initialize _value. 85 86 // It is critical for performance that this class be trivially 87 // destructable, copyable, and assignable. 88 ~markWord() = default; 89 markWord(const markWord&) = default; 90 markWord& operator=(const markWord&) = default; 91 92 static markWord from_pointer(void* ptr) { 93 return markWord((uintptr_t)ptr); 94 } 95 void* to_pointer() const { 96 return (void*)_value; 97 } 98 99 bool operator==(const markWord& other) const { 100 return _value == other._value; 101 } 102 bool operator!=(const markWord& other) const { 103 return !operator==(other); 104 } 105 106 // Conversion 107 uintptr_t value() const { return _value; } 108 109 // Constants 110 static const int age_bits = 4; 111 static const int lock_bits = 2; 112 static const int self_fwd_bits = 1; 113 static const int max_hash_bits = BitsPerWord - age_bits - lock_bits - self_fwd_bits; 114 static const int hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits; 115 static const int hash_bits_compact = hash_bits; 116 // Used only without compact headers. 117 static const int unused_gap_bits = LP64_ONLY(1) NOT_LP64(0); 118 119 static const int lock_shift = 0; 120 static const int self_fwd_shift = lock_shift + lock_bits; 121 static const int age_shift = self_fwd_shift + self_fwd_bits; 122 static const int hash_shift = age_shift + age_bits + unused_gap_bits; 123 static const int hash_shift_compact = 11; 124 125 static const uintptr_t lock_mask = right_n_bits(lock_bits); 126 static const uintptr_t lock_mask_in_place = lock_mask << lock_shift; 127 static const uintptr_t self_fwd_mask = right_n_bits(self_fwd_bits); 128 static const uintptr_t self_fwd_mask_in_place = self_fwd_mask << self_fwd_shift; 129 static const uintptr_t age_mask = right_n_bits(age_bits); 130 static const uintptr_t age_mask_in_place = age_mask << age_shift; 131 static const uintptr_t hash_mask = right_n_bits(hash_bits); 132 static const uintptr_t hash_mask_in_place = hash_mask << hash_shift; 133 static const uintptr_t hash_mask_compact = right_n_bits(hash_bits_compact); 134 static const uintptr_t hash_mask_compact_in_place = hash_mask_compact << hash_shift_compact; 135 136 #ifdef _LP64 137 // Used only with compact headers: 138 // We store nKlass in the upper 22 bits of the markword. When extracting, we need to read the upper 139 // 32 bits and rightshift by the lower 10 foreign bits. 140 141 // These are for loading the nKlass with a 32-bit load and subsequent masking of the lower 142 // shadow bits 143 static constexpr int klass_load_shift = 32; 144 static constexpr int klass_load_bits = 32; 145 static constexpr int klass_shadow_bits = 10; 146 static constexpr uintptr_t klass_shadow_mask = right_n_bits(klass_shadow_bits); 147 static constexpr uintptr_t klass_shadow_mask_inplace = klass_shadow_mask << klass_load_shift; 148 149 // These are for bit-precise extraction of the nKlass from the 64-bit Markword 150 static constexpr int klass_shift = 42; 151 static constexpr int klass_bits = 22; 152 static constexpr uintptr_t klass_mask = right_n_bits(klass_bits); 153 static constexpr uintptr_t klass_mask_in_place = klass_mask << klass_shift; 154 #endif 155 156 157 static const uintptr_t locked_value = 0; 158 static const uintptr_t unlocked_value = 1; 159 static const uintptr_t monitor_value = 2; 160 static const uintptr_t marked_value = 3; 161 162 static const uintptr_t no_hash = 0 ; // no hash value assigned 163 static const uintptr_t no_hash_in_place = (uintptr_t)no_hash << hash_shift; 164 static const uintptr_t no_lock_in_place = unlocked_value; 165 166 static const uint max_age = age_mask; 167 168 // Creates a markWord with all bits set to zero. 169 static markWord zero() { return markWord(uintptr_t(0)); } 170 171 // lock accessors (note that these assume lock_shift == 0) 172 bool is_locked() const { 173 return (mask_bits(value(), lock_mask_in_place) != unlocked_value); 174 } 175 bool is_unlocked() const { 176 return (mask_bits(value(), lock_mask_in_place) == unlocked_value); 177 } 178 bool is_marked() const { 179 return (mask_bits(value(), lock_mask_in_place) == marked_value); 180 } 181 bool is_forwarded() const { 182 // Returns true for normal forwarded (0b011) and self-forwarded (0b1xx). 183 return mask_bits(value(), lock_mask_in_place | self_fwd_mask_in_place) >= static_cast<intptr_t>(marked_value); 184 } 185 bool is_neutral() const { // Not locked, or marked - a "clean" neutral state 186 return (mask_bits(value(), lock_mask_in_place) == unlocked_value); 187 } 188 189 // Special temporary state of the markWord while being inflated. 190 // Code that looks at mark outside a lock need to take this into account. 191 bool is_being_inflated() const { return (value() == 0); } 192 193 // Distinguished markword value - used when inflating over 194 // an existing stack-lock. 0 indicates the markword is "BUSY". 195 // Lockword mutators that use a LD...CAS idiom should always 196 // check for and avoid overwriting a 0 value installed by some 197 // other thread. (They should spin or block instead. The 0 value 198 // is transient and *should* be short-lived). 199 // Fast-locking does not use INFLATING. 200 static markWord INFLATING() { return zero(); } // inflate-in-progress 201 202 // Should this header be preserved during GC? 203 bool must_be_preserved(const oopDesc* obj) const { 204 return (!is_unlocked() || !has_no_hash()); 205 } 206 207 // WARNING: The following routines are used EXCLUSIVELY by 208 // synchronization functions. They are not really gc safe. 209 // They must get updated if markWord layout get changed. 210 markWord set_unlocked() const { 211 return markWord(value() | unlocked_value); 212 } 213 bool has_locker() const { 214 assert(LockingMode == LM_LEGACY, "should only be called with legacy stack locking"); 215 return (value() & lock_mask_in_place) == locked_value; 216 } 217 BasicLock* locker() const { 218 assert(has_locker(), "check"); 219 return (BasicLock*) value(); 220 } 221 222 bool is_fast_locked() const { 223 assert(LockingMode == LM_LIGHTWEIGHT, "should only be called with new lightweight locking"); 224 return (value() & lock_mask_in_place) == locked_value; 225 } 226 markWord set_fast_locked() const { 227 // Clear the lock_mask_in_place bits to set locked_value: 228 return markWord(value() & ~lock_mask_in_place); 229 } 230 231 bool has_monitor() const { 232 return ((value() & lock_mask_in_place) == monitor_value); 233 } 234 ObjectMonitor* monitor() const { 235 assert(has_monitor(), "check"); 236 assert(LockingMode != LM_LIGHTWEIGHT, "Lightweight locking does not use markWord for monitors"); 237 // Use xor instead of &~ to provide one extra tag-bit check. 238 return (ObjectMonitor*) (value() ^ monitor_value); 239 } 240 bool has_displaced_mark_helper() const { 241 intptr_t lockbits = value() & lock_mask_in_place; 242 return LockingMode == LM_LIGHTWEIGHT ? false // no displaced mark 243 : (lockbits & unlocked_value) == 0; // monitor | stack-locked? 244 } 245 markWord displaced_mark_helper() const; 246 void set_displaced_mark_helper(markWord m) const; 247 markWord copy_set_hash(intptr_t hash) const { 248 if (UseCompactObjectHeaders) { 249 uintptr_t tmp = value() & (~hash_mask_compact_in_place); 250 tmp |= ((hash & hash_mask_compact) << hash_shift_compact); 251 return markWord(tmp); 252 } else { 253 uintptr_t tmp = value() & (~hash_mask_in_place); 254 tmp |= ((hash & hash_mask) << hash_shift); 255 return markWord(tmp); 256 } 257 } 258 // it is only used to be stored into BasicLock as the 259 // indicator that the lock is using heavyweight monitor 260 static markWord unused_mark() { 261 return markWord(marked_value); 262 } 263 // the following two functions create the markWord to be 264 // stored into object header, it encodes monitor info 265 static markWord encode(BasicLock* lock) { 266 return from_pointer(lock); 267 } 268 static markWord encode(ObjectMonitor* monitor) { 269 assert(LockingMode != LM_LIGHTWEIGHT, "Lightweight locking does not use markWord for monitors"); 270 uintptr_t tmp = (uintptr_t) monitor; 271 return markWord(tmp | monitor_value); 272 } 273 274 markWord set_has_monitor() const { 275 return markWord((value() & ~lock_mask_in_place) | monitor_value); 276 } 277 278 // used to encode pointers during GC 279 markWord clear_lock_bits() const { return markWord(value() & ~lock_mask_in_place); } 280 281 // age operations 282 markWord set_marked() { return markWord((value() & ~lock_mask_in_place) | marked_value); } 283 markWord set_unmarked() { return markWord((value() & ~lock_mask_in_place) | unlocked_value); } 284 285 uint age() const { return (uint) mask_bits(value() >> age_shift, age_mask); } 286 markWord set_age(uint v) const { 287 assert((v & ~age_mask) == 0, "shouldn't overflow age field"); 288 return markWord((value() & ~age_mask_in_place) | ((v & age_mask) << age_shift)); 289 } 290 markWord incr_age() const { return age() == max_age ? markWord(_value) : set_age(age() + 1); } 291 292 // hash operations 293 intptr_t hash() const { 294 if (UseCompactObjectHeaders) { 295 return mask_bits(value() >> hash_shift_compact, hash_mask_compact); 296 } else { 297 return mask_bits(value() >> hash_shift, hash_mask); 298 } 299 } 300 301 bool has_no_hash() const { 302 return hash() == no_hash; 303 } 304 305 inline Klass* klass() const; 306 inline Klass* klass_or_null() const; 307 inline Klass* klass_without_asserts() const; 308 inline narrowKlass narrow_klass() const; 309 inline markWord set_narrow_klass(narrowKlass nklass) const; 310 inline markWord set_klass(Klass* klass) const; 311 312 // Prototype mark for initialization 313 static markWord prototype() { 314 return markWord( no_hash_in_place | no_lock_in_place ); 315 } 316 317 // Debugging 318 void print_on(outputStream* st, bool print_monitor_info = true) const; 319 320 // Prepare address of oop for placement into mark 321 inline static markWord encode_pointer_as_mark(void* p) { return from_pointer(p).set_marked(); } 322 323 // Recover address of oop from encoded form used in mark 324 inline void* decode_pointer() { return (void*)clear_lock_bits().value(); } 325 326 inline bool self_forwarded() const { 327 NOT_LP64(assert(LockingMode != LM_LEGACY, "incorrect with LM_LEGACY on 32 bit");) 328 return mask_bits(value(), self_fwd_mask_in_place) != 0; 329 } 330 331 inline markWord set_self_forwarded() const { 332 NOT_LP64(assert(LockingMode != LM_LEGACY, "incorrect with LM_LEGACY on 32 bit");) 333 return markWord(value() | self_fwd_mask_in_place); 334 } 335 336 inline markWord unset_self_forwarded() const { 337 NOT_LP64(assert(LockingMode != LM_LEGACY, "incorrect with LM_LEGACY on 32 bit");) 338 return markWord(value() & ~self_fwd_mask_in_place); 339 } 340 }; 341 342 // Support atomic operations. 343 template<> 344 struct PrimitiveConversions::Translate<markWord> : public std::true_type { 345 typedef markWord Value; 346 typedef uintptr_t Decayed; 347 348 static Decayed decay(const Value& x) { return x.value(); } 349 static Value recover(Decayed x) { return Value(x); } 350 }; 351 352 #endif // SHARE_OOPS_MARKWORD_HPP