1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_RUNTIME_MIRROR_OBJECT_INL_H_ 18 #define ART_RUNTIME_MIRROR_OBJECT_INL_H_ 19 20 #include "object.h" 21 22 #include "art_field.h" 23 #include "art_method.h" 24 #include "atomic.h" 25 #include "array-inl.h" 26 #include "class.h" 27 #include "class_flags.h" 28 #include "class_linker.h" 29 #include "class_loader-inl.h" 30 #include "dex_cache-inl.h" 31 #include "lock_word-inl.h" 32 #include "monitor.h" 33 #include "object_array-inl.h" 34 #include "read_barrier-inl.h" 35 #include "reference.h" 36 #include "runtime.h" 37 #include "string-inl.h" 38 #include "throwable.h" 39 40 namespace art { 41 namespace mirror { 42 43 inline uint32_t Object::ClassSize(size_t pointer_size) { 44 uint32_t vtable_entries = kVTableLength; 45 return Class::ComputeClassSize(true, vtable_entries, 0, 0, 0, 0, 0, pointer_size); 46 } 47 48 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 49 inline Class* Object::GetClass() { 50 return GetFieldObject<Class, kVerifyFlags, kReadBarrierOption>( 51 OFFSET_OF_OBJECT_MEMBER(Object, klass_)); 52 } 53 54 template<VerifyObjectFlags kVerifyFlags> 55 inline void Object::SetClass(Class* new_klass) { 56 // new_klass may be null prior to class linker initialization. 57 // We don't mark the card as this occurs as part of object allocation. Not all objects have 58 // backing cards, such as large objects. 59 // We use non transactional version since we can't undo this write. We also disable checking as 60 // we may run in transaction mode here. 61 SetFieldObjectWithoutWriteBarrier<false, false, 62 static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis)>( 63 OFFSET_OF_OBJECT_MEMBER(Object, klass_), new_klass); 64 } 65 66 template<VerifyObjectFlags kVerifyFlags> 67 inline LockWord Object::GetLockWord(bool as_volatile) { 68 if (as_volatile) { 69 return LockWord(GetField32Volatile<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Object, monitor_))); 70 } 71 return LockWord(GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(Object, monitor_))); 72 } 73 74 template<VerifyObjectFlags kVerifyFlags> 75 inline void Object::SetLockWord(LockWord new_val, bool as_volatile) { 76 // Force use of non-transactional mode and do not check. 77 if (as_volatile) { 78 SetField32Volatile<false, false, kVerifyFlags>( 79 OFFSET_OF_OBJECT_MEMBER(Object, monitor_), new_val.GetValue()); 80 } else { 81 SetField32<false, false, kVerifyFlags>( 82 OFFSET_OF_OBJECT_MEMBER(Object, monitor_), new_val.GetValue()); 83 } 84 } 85 86 inline bool Object::CasLockWordWeakSequentiallyConsistent(LockWord old_val, LockWord new_val) { 87 // Force use of non-transactional mode and do not check. 88 return CasFieldWeakSequentiallyConsistent32<false, false>( 89 OFFSET_OF_OBJECT_MEMBER(Object, monitor_), old_val.GetValue(), new_val.GetValue()); 90 } 91 92 inline bool Object::CasLockWordWeakRelaxed(LockWord old_val, LockWord new_val) { 93 // Force use of non-transactional mode and do not check. 94 return CasFieldWeakRelaxed32<false, false>( 95 OFFSET_OF_OBJECT_MEMBER(Object, monitor_), old_val.GetValue(), new_val.GetValue()); 96 } 97 98 inline bool Object::CasLockWordWeakRelease(LockWord old_val, LockWord new_val) { 99 // Force use of non-transactional mode and do not check. 100 return CasFieldWeakRelease32<false, false>( 101 OFFSET_OF_OBJECT_MEMBER(Object, monitor_), old_val.GetValue(), new_val.GetValue()); 102 } 103 104 inline uint32_t Object::GetLockOwnerThreadId() { 105 return Monitor::GetLockOwnerThreadId(this); 106 } 107 108 inline mirror::Object* Object::MonitorEnter(Thread* self) { 109 return Monitor::MonitorEnter(self, this); 110 } 111 112 inline bool Object::MonitorExit(Thread* self) { 113 return Monitor::MonitorExit(self, this); 114 } 115 116 inline void Object::Notify(Thread* self) { 117 Monitor::Notify(self, this); 118 } 119 120 inline void Object::NotifyAll(Thread* self) { 121 Monitor::NotifyAll(self, this); 122 } 123 124 inline void Object::Wait(Thread* self) { 125 Monitor::Wait(self, this, 0, 0, true, kWaiting); 126 } 127 128 inline void Object::Wait(Thread* self, int64_t ms, int32_t ns) { 129 Monitor::Wait(self, this, ms, ns, true, kTimedWaiting); 130 } 131 132 inline Object* Object::GetReadBarrierPointer() { 133 #ifdef USE_BAKER_READ_BARRIER 134 DCHECK(kUseBakerReadBarrier); 135 return reinterpret_cast<Object*>(GetLockWord(false).ReadBarrierState()); 136 #elif USE_BROOKS_READ_BARRIER 137 DCHECK(kUseBrooksReadBarrier); 138 return GetFieldObject<Object, kVerifyNone, kWithoutReadBarrier>( 139 OFFSET_OF_OBJECT_MEMBER(Object, x_rb_ptr_)); 140 #else 141 LOG(FATAL) << "Unreachable"; 142 UNREACHABLE(); 143 #endif 144 } 145 146 inline void Object::SetReadBarrierPointer(Object* rb_ptr) { 147 #ifdef USE_BAKER_READ_BARRIER 148 DCHECK(kUseBakerReadBarrier); 149 DCHECK_EQ(reinterpret_cast<uint64_t>(rb_ptr) >> 32, 0U); 150 LockWord lw = GetLockWord(false); 151 lw.SetReadBarrierState(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(rb_ptr))); 152 SetLockWord(lw, false); 153 #elif USE_BROOKS_READ_BARRIER 154 DCHECK(kUseBrooksReadBarrier); 155 // We don't mark the card as this occurs as part of object allocation. Not all objects have 156 // backing cards, such as large objects. 157 SetFieldObjectWithoutWriteBarrier<false, false, kVerifyNone>( 158 OFFSET_OF_OBJECT_MEMBER(Object, x_rb_ptr_), rb_ptr); 159 #else 160 LOG(FATAL) << "Unreachable"; 161 UNREACHABLE(); 162 UNUSED(rb_ptr); 163 #endif 164 } 165 166 template<bool kCasRelease> 167 inline bool Object::AtomicSetReadBarrierPointer(Object* expected_rb_ptr, Object* rb_ptr) { 168 #ifdef USE_BAKER_READ_BARRIER 169 DCHECK(kUseBakerReadBarrier); 170 DCHECK_EQ(reinterpret_cast<uint64_t>(expected_rb_ptr) >> 32, 0U); 171 DCHECK_EQ(reinterpret_cast<uint64_t>(rb_ptr) >> 32, 0U); 172 LockWord expected_lw; 173 LockWord new_lw; 174 do { 175 LockWord lw = GetLockWord(false); 176 if (UNLIKELY(reinterpret_cast<Object*>(lw.ReadBarrierState()) != expected_rb_ptr)) { 177 // Lost the race. 178 return false; 179 } 180 expected_lw = lw; 181 expected_lw.SetReadBarrierState( 182 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(expected_rb_ptr))); 183 new_lw = lw; 184 new_lw.SetReadBarrierState(static_cast<uint32_t>(reinterpret_cast<uintptr_t>(rb_ptr))); 185 // ConcurrentCopying::ProcessMarkStackRef uses this with kCasRelease == true. 186 // If kCasRelease == true, use a CAS release so that when GC updates all the fields of 187 // an object and then changes the object from gray to black, the field updates (stores) will be 188 // visible (won't be reordered after this CAS.) 189 } while (!(kCasRelease ? 190 CasLockWordWeakRelease(expected_lw, new_lw) : 191 CasLockWordWeakRelaxed(expected_lw, new_lw))); 192 return true; 193 #elif USE_BROOKS_READ_BARRIER 194 DCHECK(kUseBrooksReadBarrier); 195 MemberOffset offset = OFFSET_OF_OBJECT_MEMBER(Object, x_rb_ptr_); 196 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + offset.SizeValue(); 197 Atomic<uint32_t>* atomic_rb_ptr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); 198 HeapReference<Object> expected_ref(HeapReference<Object>::FromMirrorPtr(expected_rb_ptr)); 199 HeapReference<Object> new_ref(HeapReference<Object>::FromMirrorPtr(rb_ptr)); 200 do { 201 if (UNLIKELY(atomic_rb_ptr->LoadRelaxed() != expected_ref.reference_)) { 202 // Lost the race. 203 return false; 204 } 205 } while (!atomic_rb_ptr->CompareExchangeWeakSequentiallyConsistent(expected_ref.reference_, 206 new_ref.reference_)); 207 return true; 208 #else 209 UNUSED(expected_rb_ptr, rb_ptr); 210 LOG(FATAL) << "Unreachable"; 211 UNREACHABLE(); 212 #endif 213 } 214 215 inline void Object::AssertReadBarrierPointer() const { 216 if (kUseBakerReadBarrier) { 217 Object* obj = const_cast<Object*>(this); 218 DCHECK(obj->GetReadBarrierPointer() == nullptr) 219 << "Bad Baker pointer: obj=" << reinterpret_cast<void*>(obj) 220 << " ptr=" << reinterpret_cast<void*>(obj->GetReadBarrierPointer()); 221 } else { 222 CHECK(kUseBrooksReadBarrier); 223 Object* obj = const_cast<Object*>(this); 224 DCHECK_EQ(obj, obj->GetReadBarrierPointer()) 225 << "Bad Brooks pointer: obj=" << reinterpret_cast<void*>(obj) 226 << " ptr=" << reinterpret_cast<void*>(obj->GetReadBarrierPointer()); 227 } 228 } 229 230 template<VerifyObjectFlags kVerifyFlags> 231 inline bool Object::VerifierInstanceOf(Class* klass) { 232 DCHECK(klass != nullptr); 233 DCHECK(GetClass<kVerifyFlags>() != nullptr); 234 return klass->IsInterface() || InstanceOf(klass); 235 } 236 237 template<VerifyObjectFlags kVerifyFlags> 238 inline bool Object::InstanceOf(Class* klass) { 239 DCHECK(klass != nullptr); 240 DCHECK(GetClass<kVerifyNone>() != nullptr); 241 return klass->IsAssignableFrom(GetClass<kVerifyFlags>()); 242 } 243 244 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 245 inline bool Object::IsClass() { 246 Class* java_lang_Class = GetClass<kVerifyFlags, kReadBarrierOption>()-> 247 template GetClass<kVerifyFlags, kReadBarrierOption>(); 248 return GetClass<static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis), 249 kReadBarrierOption>() == java_lang_Class; 250 } 251 252 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 253 inline Class* Object::AsClass() { 254 DCHECK((IsClass<kVerifyFlags, kReadBarrierOption>())); 255 return down_cast<Class*>(this); 256 } 257 258 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 259 inline bool Object::IsObjectArray() { 260 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 261 return IsArrayInstance<kVerifyFlags, kReadBarrierOption>() && 262 !GetClass<kNewFlags, kReadBarrierOption>()-> 263 template GetComponentType<kNewFlags, kReadBarrierOption>()->IsPrimitive(); 264 } 265 266 template<class T, VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 267 inline ObjectArray<T>* Object::AsObjectArray() { 268 DCHECK((IsObjectArray<kVerifyFlags, kReadBarrierOption>())); 269 return down_cast<ObjectArray<T>*>(this); 270 } 271 272 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 273 inline bool Object::IsArrayInstance() { 274 return GetClass<kVerifyFlags, kReadBarrierOption>()-> 275 template IsArrayClass<kVerifyFlags, kReadBarrierOption>(); 276 } 277 278 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 279 inline bool Object::IsReferenceInstance() { 280 return GetClass<kVerifyFlags, kReadBarrierOption>()->IsTypeOfReferenceClass(); 281 } 282 283 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 284 inline Reference* Object::AsReference() { 285 DCHECK((IsReferenceInstance<kVerifyFlags, kReadBarrierOption>())); 286 return down_cast<Reference*>(this); 287 } 288 289 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 290 inline Array* Object::AsArray() { 291 DCHECK((IsArrayInstance<kVerifyFlags, kReadBarrierOption>())); 292 return down_cast<Array*>(this); 293 } 294 295 template<VerifyObjectFlags kVerifyFlags> 296 inline BooleanArray* Object::AsBooleanArray() { 297 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 298 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 299 DCHECK(GetClass<kNewFlags>()->GetComponentType()->IsPrimitiveBoolean()); 300 return down_cast<BooleanArray*>(this); 301 } 302 303 template<VerifyObjectFlags kVerifyFlags> 304 inline ByteArray* Object::AsByteArray() { 305 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 306 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 307 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveByte()); 308 return down_cast<ByteArray*>(this); 309 } 310 311 template<VerifyObjectFlags kVerifyFlags> 312 inline ByteArray* Object::AsByteSizedArray() { 313 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 314 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 315 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveByte() || 316 GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveBoolean()); 317 return down_cast<ByteArray*>(this); 318 } 319 320 template<VerifyObjectFlags kVerifyFlags> 321 inline CharArray* Object::AsCharArray() { 322 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 323 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 324 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveChar()); 325 return down_cast<CharArray*>(this); 326 } 327 328 template<VerifyObjectFlags kVerifyFlags> 329 inline ShortArray* Object::AsShortArray() { 330 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 331 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 332 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveShort()); 333 return down_cast<ShortArray*>(this); 334 } 335 336 template<VerifyObjectFlags kVerifyFlags> 337 inline ShortArray* Object::AsShortSizedArray() { 338 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 339 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 340 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveShort() || 341 GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveChar()); 342 return down_cast<ShortArray*>(this); 343 } 344 345 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 346 inline bool Object::IsIntArray() { 347 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 348 mirror::Class* klass = GetClass<kVerifyFlags, kReadBarrierOption>(); 349 mirror::Class* component_type = klass->GetComponentType<kVerifyFlags, kReadBarrierOption>(); 350 return component_type != nullptr && component_type->template IsPrimitiveInt<kNewFlags>(); 351 } 352 353 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 354 inline IntArray* Object::AsIntArray() { 355 DCHECK((IsIntArray<kVerifyFlags, kReadBarrierOption>())); 356 return down_cast<IntArray*>(this); 357 } 358 359 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 360 inline bool Object::IsLongArray() { 361 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 362 mirror::Class* klass = GetClass<kVerifyFlags, kReadBarrierOption>(); 363 mirror::Class* component_type = klass->GetComponentType<kVerifyFlags, kReadBarrierOption>(); 364 return component_type != nullptr && component_type->template IsPrimitiveLong<kNewFlags>(); 365 } 366 367 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 368 inline LongArray* Object::AsLongArray() { 369 DCHECK((IsLongArray<kVerifyFlags, kReadBarrierOption>())); 370 return down_cast<LongArray*>(this); 371 } 372 373 template<VerifyObjectFlags kVerifyFlags> 374 inline bool Object::IsFloatArray() { 375 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 376 auto* component_type = GetClass<kVerifyFlags>()->GetComponentType(); 377 return component_type != nullptr && component_type->template IsPrimitiveFloat<kNewFlags>(); 378 } 379 380 template<VerifyObjectFlags kVerifyFlags> 381 inline FloatArray* Object::AsFloatArray() { 382 DCHECK(IsFloatArray<kVerifyFlags>()); 383 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 384 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 385 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveFloat()); 386 return down_cast<FloatArray*>(this); 387 } 388 389 template<VerifyObjectFlags kVerifyFlags> 390 inline bool Object::IsDoubleArray() { 391 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 392 auto* component_type = GetClass<kVerifyFlags>()->GetComponentType(); 393 return component_type != nullptr && component_type->template IsPrimitiveDouble<kNewFlags>(); 394 } 395 396 template<VerifyObjectFlags kVerifyFlags> 397 inline DoubleArray* Object::AsDoubleArray() { 398 DCHECK(IsDoubleArray<kVerifyFlags>()); 399 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 400 DCHECK(GetClass<kVerifyFlags>()->IsArrayClass()); 401 DCHECK(GetClass<kNewFlags>()->template GetComponentType<kNewFlags>()->IsPrimitiveDouble()); 402 return down_cast<DoubleArray*>(this); 403 } 404 405 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 406 inline bool Object::IsString() { 407 return GetClass<kVerifyFlags, kReadBarrierOption>()->IsStringClass(); 408 } 409 410 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 411 inline String* Object::AsString() { 412 DCHECK((IsString<kVerifyFlags, kReadBarrierOption>())); 413 return down_cast<String*>(this); 414 } 415 416 template<VerifyObjectFlags kVerifyFlags> 417 inline Throwable* Object::AsThrowable() { 418 DCHECK(GetClass<kVerifyFlags>()->IsThrowableClass()); 419 return down_cast<Throwable*>(this); 420 } 421 422 template<VerifyObjectFlags kVerifyFlags> 423 inline bool Object::IsWeakReferenceInstance() { 424 return GetClass<kVerifyFlags>()->IsWeakReferenceClass(); 425 } 426 427 template<VerifyObjectFlags kVerifyFlags> 428 inline bool Object::IsSoftReferenceInstance() { 429 return GetClass<kVerifyFlags>()->IsSoftReferenceClass(); 430 } 431 432 template<VerifyObjectFlags kVerifyFlags> 433 inline bool Object::IsFinalizerReferenceInstance() { 434 return GetClass<kVerifyFlags>()->IsFinalizerReferenceClass(); 435 } 436 437 template<VerifyObjectFlags kVerifyFlags> 438 inline FinalizerReference* Object::AsFinalizerReference() { 439 DCHECK(IsFinalizerReferenceInstance<kVerifyFlags>()); 440 return down_cast<FinalizerReference*>(this); 441 } 442 443 template<VerifyObjectFlags kVerifyFlags> 444 inline bool Object::IsPhantomReferenceInstance() { 445 return GetClass<kVerifyFlags>()->IsPhantomReferenceClass(); 446 } 447 448 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 449 inline size_t Object::SizeOf() { 450 size_t result; 451 constexpr auto kNewFlags = static_cast<VerifyObjectFlags>(kVerifyFlags & ~kVerifyThis); 452 if (IsArrayInstance<kVerifyFlags, kReadBarrierOption>()) { 453 result = AsArray<kNewFlags, kReadBarrierOption>()-> 454 template SizeOf<kNewFlags, kReadBarrierOption>(); 455 } else if (IsClass<kNewFlags, kReadBarrierOption>()) { 456 result = AsClass<kNewFlags, kReadBarrierOption>()-> 457 template SizeOf<kNewFlags, kReadBarrierOption>(); 458 } else if (GetClass<kNewFlags, kReadBarrierOption>()->IsStringClass()) { 459 result = AsString<kNewFlags, kReadBarrierOption>()-> 460 template SizeOf<kNewFlags>(); 461 } else { 462 result = GetClass<kNewFlags, kReadBarrierOption>()-> 463 template GetObjectSize<kNewFlags, kReadBarrierOption>(); 464 } 465 DCHECK_GE(result, sizeof(Object)) 466 << " class=" << PrettyTypeOf(GetClass<kNewFlags, kReadBarrierOption>()); 467 return result; 468 } 469 470 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 471 inline uint8_t Object::GetFieldBoolean(MemberOffset field_offset) { 472 if (kVerifyFlags & kVerifyThis) { 473 VerifyObject(this); 474 } 475 return GetField<uint8_t, kIsVolatile>(field_offset); 476 } 477 478 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 479 inline int8_t Object::GetFieldByte(MemberOffset field_offset) { 480 if (kVerifyFlags & kVerifyThis) { 481 VerifyObject(this); 482 } 483 return GetField<int8_t, kIsVolatile>(field_offset); 484 } 485 486 template<VerifyObjectFlags kVerifyFlags> 487 inline uint8_t Object::GetFieldBooleanVolatile(MemberOffset field_offset) { 488 return GetFieldBoolean<kVerifyFlags, true>(field_offset); 489 } 490 491 template<VerifyObjectFlags kVerifyFlags> 492 inline int8_t Object::GetFieldByteVolatile(MemberOffset field_offset) { 493 return GetFieldByte<kVerifyFlags, true>(field_offset); 494 } 495 496 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 497 bool kIsVolatile> 498 inline void Object::SetFieldBoolean(MemberOffset field_offset, uint8_t new_value) 499 SHARED_REQUIRES(Locks::mutator_lock_) { 500 if (kCheckTransaction) { 501 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 502 } 503 if (kTransactionActive) { 504 Runtime::Current()->RecordWriteFieldBoolean(this, field_offset, 505 GetFieldBoolean<kVerifyFlags, kIsVolatile>(field_offset), 506 kIsVolatile); 507 } 508 if (kVerifyFlags & kVerifyThis) { 509 VerifyObject(this); 510 } 511 SetField<uint8_t, kIsVolatile>(field_offset, new_value); 512 } 513 514 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 515 bool kIsVolatile> 516 inline void Object::SetFieldByte(MemberOffset field_offset, int8_t new_value) 517 SHARED_REQUIRES(Locks::mutator_lock_) { 518 if (kCheckTransaction) { 519 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 520 } 521 if (kTransactionActive) { 522 Runtime::Current()->RecordWriteFieldByte(this, field_offset, 523 GetFieldByte<kVerifyFlags, kIsVolatile>(field_offset), 524 kIsVolatile); 525 } 526 if (kVerifyFlags & kVerifyThis) { 527 VerifyObject(this); 528 } 529 SetField<int8_t, kIsVolatile>(field_offset, new_value); 530 } 531 532 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 533 inline void Object::SetFieldBooleanVolatile(MemberOffset field_offset, uint8_t new_value) { 534 return SetFieldBoolean<kTransactionActive, kCheckTransaction, kVerifyFlags, true>( 535 field_offset, new_value); 536 } 537 538 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 539 inline void Object::SetFieldByteVolatile(MemberOffset field_offset, int8_t new_value) { 540 return SetFieldByte<kTransactionActive, kCheckTransaction, kVerifyFlags, true>( 541 field_offset, new_value); 542 } 543 544 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 545 inline uint16_t Object::GetFieldChar(MemberOffset field_offset) { 546 if (kVerifyFlags & kVerifyThis) { 547 VerifyObject(this); 548 } 549 return GetField<uint16_t, kIsVolatile>(field_offset); 550 } 551 552 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 553 inline int16_t Object::GetFieldShort(MemberOffset field_offset) { 554 if (kVerifyFlags & kVerifyThis) { 555 VerifyObject(this); 556 } 557 return GetField<int16_t, kIsVolatile>(field_offset); 558 } 559 560 template<VerifyObjectFlags kVerifyFlags> 561 inline uint16_t Object::GetFieldCharVolatile(MemberOffset field_offset) { 562 return GetFieldChar<kVerifyFlags, true>(field_offset); 563 } 564 565 template<VerifyObjectFlags kVerifyFlags> 566 inline int16_t Object::GetFieldShortVolatile(MemberOffset field_offset) { 567 return GetFieldShort<kVerifyFlags, true>(field_offset); 568 } 569 570 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 571 bool kIsVolatile> 572 inline void Object::SetFieldChar(MemberOffset field_offset, uint16_t new_value) { 573 if (kCheckTransaction) { 574 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 575 } 576 if (kTransactionActive) { 577 Runtime::Current()->RecordWriteFieldChar(this, field_offset, 578 GetFieldChar<kVerifyFlags, kIsVolatile>(field_offset), 579 kIsVolatile); 580 } 581 if (kVerifyFlags & kVerifyThis) { 582 VerifyObject(this); 583 } 584 SetField<uint16_t, kIsVolatile>(field_offset, new_value); 585 } 586 587 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 588 bool kIsVolatile> 589 inline void Object::SetFieldShort(MemberOffset field_offset, int16_t new_value) { 590 if (kCheckTransaction) { 591 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 592 } 593 if (kTransactionActive) { 594 Runtime::Current()->RecordWriteFieldChar(this, field_offset, 595 GetFieldShort<kVerifyFlags, kIsVolatile>(field_offset), 596 kIsVolatile); 597 } 598 if (kVerifyFlags & kVerifyThis) { 599 VerifyObject(this); 600 } 601 SetField<int16_t, kIsVolatile>(field_offset, new_value); 602 } 603 604 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 605 inline void Object::SetFieldCharVolatile(MemberOffset field_offset, uint16_t new_value) { 606 return SetFieldChar<kTransactionActive, kCheckTransaction, kVerifyFlags, true>( 607 field_offset, new_value); 608 } 609 610 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 611 inline void Object::SetFieldShortVolatile(MemberOffset field_offset, int16_t new_value) { 612 return SetFieldShort<kTransactionActive, kCheckTransaction, kVerifyFlags, true>( 613 field_offset, new_value); 614 } 615 616 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 617 inline int32_t Object::GetField32(MemberOffset field_offset) { 618 if (kVerifyFlags & kVerifyThis) { 619 VerifyObject(this); 620 } 621 return GetField<int32_t, kIsVolatile>(field_offset); 622 } 623 624 template<VerifyObjectFlags kVerifyFlags> 625 inline int32_t Object::GetField32Volatile(MemberOffset field_offset) { 626 return GetField32<kVerifyFlags, true>(field_offset); 627 } 628 629 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 630 bool kIsVolatile> 631 inline void Object::SetField32(MemberOffset field_offset, int32_t new_value) { 632 if (kCheckTransaction) { 633 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 634 } 635 if (kTransactionActive) { 636 Runtime::Current()->RecordWriteField32(this, field_offset, 637 GetField32<kVerifyFlags, kIsVolatile>(field_offset), 638 kIsVolatile); 639 } 640 if (kVerifyFlags & kVerifyThis) { 641 VerifyObject(this); 642 } 643 SetField<int32_t, kIsVolatile>(field_offset, new_value); 644 } 645 646 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 647 inline void Object::SetField32Volatile(MemberOffset field_offset, int32_t new_value) { 648 SetField32<kTransactionActive, kCheckTransaction, kVerifyFlags, true>(field_offset, new_value); 649 } 650 651 // TODO: Pass memory_order_ and strong/weak as arguments to avoid code duplication? 652 653 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 654 inline bool Object::CasFieldWeakSequentiallyConsistent32(MemberOffset field_offset, 655 int32_t old_value, int32_t new_value) { 656 if (kCheckTransaction) { 657 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 658 } 659 if (kTransactionActive) { 660 Runtime::Current()->RecordWriteField32(this, field_offset, old_value, true); 661 } 662 if (kVerifyFlags & kVerifyThis) { 663 VerifyObject(this); 664 } 665 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 666 AtomicInteger* atomic_addr = reinterpret_cast<AtomicInteger*>(raw_addr); 667 668 return atomic_addr->CompareExchangeWeakSequentiallyConsistent(old_value, new_value); 669 } 670 671 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 672 inline bool Object::CasFieldWeakRelaxed32(MemberOffset field_offset, 673 int32_t old_value, int32_t new_value) { 674 if (kCheckTransaction) { 675 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 676 } 677 if (kTransactionActive) { 678 Runtime::Current()->RecordWriteField32(this, field_offset, old_value, true); 679 } 680 if (kVerifyFlags & kVerifyThis) { 681 VerifyObject(this); 682 } 683 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 684 AtomicInteger* atomic_addr = reinterpret_cast<AtomicInteger*>(raw_addr); 685 686 return atomic_addr->CompareExchangeWeakRelaxed(old_value, new_value); 687 } 688 689 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 690 inline bool Object::CasFieldWeakRelease32(MemberOffset field_offset, 691 int32_t old_value, int32_t new_value) { 692 if (kCheckTransaction) { 693 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 694 } 695 if (kTransactionActive) { 696 Runtime::Current()->RecordWriteField32(this, field_offset, old_value, true); 697 } 698 if (kVerifyFlags & kVerifyThis) { 699 VerifyObject(this); 700 } 701 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 702 AtomicInteger* atomic_addr = reinterpret_cast<AtomicInteger*>(raw_addr); 703 704 return atomic_addr->CompareExchangeWeakRelease(old_value, new_value); 705 } 706 707 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 708 inline bool Object::CasFieldStrongSequentiallyConsistent32(MemberOffset field_offset, 709 int32_t old_value, int32_t new_value) { 710 if (kCheckTransaction) { 711 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 712 } 713 if (kTransactionActive) { 714 Runtime::Current()->RecordWriteField32(this, field_offset, old_value, true); 715 } 716 if (kVerifyFlags & kVerifyThis) { 717 VerifyObject(this); 718 } 719 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 720 AtomicInteger* atomic_addr = reinterpret_cast<AtomicInteger*>(raw_addr); 721 722 return atomic_addr->CompareExchangeStrongSequentiallyConsistent(old_value, new_value); 723 } 724 725 template<VerifyObjectFlags kVerifyFlags, bool kIsVolatile> 726 inline int64_t Object::GetField64(MemberOffset field_offset) { 727 if (kVerifyFlags & kVerifyThis) { 728 VerifyObject(this); 729 } 730 return GetField<int64_t, kIsVolatile>(field_offset); 731 } 732 733 template<VerifyObjectFlags kVerifyFlags> 734 inline int64_t Object::GetField64Volatile(MemberOffset field_offset) { 735 return GetField64<kVerifyFlags, true>(field_offset); 736 } 737 738 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 739 bool kIsVolatile> 740 inline void Object::SetField64(MemberOffset field_offset, int64_t new_value) { 741 if (kCheckTransaction) { 742 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 743 } 744 if (kTransactionActive) { 745 Runtime::Current()->RecordWriteField64(this, field_offset, 746 GetField64<kVerifyFlags, kIsVolatile>(field_offset), 747 kIsVolatile); 748 } 749 if (kVerifyFlags & kVerifyThis) { 750 VerifyObject(this); 751 } 752 SetField<int64_t, kIsVolatile>(field_offset, new_value); 753 } 754 755 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 756 inline void Object::SetField64Volatile(MemberOffset field_offset, int64_t new_value) { 757 return SetField64<kTransactionActive, kCheckTransaction, kVerifyFlags, true>(field_offset, 758 new_value); 759 } 760 761 template<typename kSize, bool kIsVolatile> 762 inline void Object::SetField(MemberOffset field_offset, kSize new_value) { 763 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 764 kSize* addr = reinterpret_cast<kSize*>(raw_addr); 765 if (kIsVolatile) { 766 reinterpret_cast<Atomic<kSize>*>(addr)->StoreSequentiallyConsistent(new_value); 767 } else { 768 reinterpret_cast<Atomic<kSize>*>(addr)->StoreJavaData(new_value); 769 } 770 } 771 772 template<typename kSize, bool kIsVolatile> 773 inline kSize Object::GetField(MemberOffset field_offset) { 774 const uint8_t* raw_addr = reinterpret_cast<const uint8_t*>(this) + field_offset.Int32Value(); 775 const kSize* addr = reinterpret_cast<const kSize*>(raw_addr); 776 if (kIsVolatile) { 777 return reinterpret_cast<const Atomic<kSize>*>(addr)->LoadSequentiallyConsistent(); 778 } else { 779 return reinterpret_cast<const Atomic<kSize>*>(addr)->LoadJavaData(); 780 } 781 } 782 783 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 784 inline bool Object::CasFieldWeakSequentiallyConsistent64(MemberOffset field_offset, 785 int64_t old_value, int64_t new_value) { 786 if (kCheckTransaction) { 787 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 788 } 789 if (kTransactionActive) { 790 Runtime::Current()->RecordWriteField64(this, field_offset, old_value, true); 791 } 792 if (kVerifyFlags & kVerifyThis) { 793 VerifyObject(this); 794 } 795 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 796 Atomic<int64_t>* atomic_addr = reinterpret_cast<Atomic<int64_t>*>(raw_addr); 797 return atomic_addr->CompareExchangeWeakSequentiallyConsistent(old_value, new_value); 798 } 799 800 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 801 inline bool Object::CasFieldStrongSequentiallyConsistent64(MemberOffset field_offset, 802 int64_t old_value, int64_t new_value) { 803 if (kCheckTransaction) { 804 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 805 } 806 if (kTransactionActive) { 807 Runtime::Current()->RecordWriteField64(this, field_offset, old_value, true); 808 } 809 if (kVerifyFlags & kVerifyThis) { 810 VerifyObject(this); 811 } 812 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 813 Atomic<int64_t>* atomic_addr = reinterpret_cast<Atomic<int64_t>*>(raw_addr); 814 return atomic_addr->CompareExchangeStrongSequentiallyConsistent(old_value, new_value); 815 } 816 817 template<class T, VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption, 818 bool kIsVolatile> 819 inline T* Object::GetFieldObject(MemberOffset field_offset) { 820 if (kVerifyFlags & kVerifyThis) { 821 VerifyObject(this); 822 } 823 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 824 HeapReference<T>* objref_addr = reinterpret_cast<HeapReference<T>*>(raw_addr); 825 T* result = ReadBarrier::Barrier<T, kReadBarrierOption>(this, field_offset, objref_addr); 826 if (kIsVolatile) { 827 // TODO: Refactor to use a SequentiallyConsistent load instead. 828 QuasiAtomic::ThreadFenceAcquire(); // Ensure visibility of operations preceding store. 829 } 830 if (kVerifyFlags & kVerifyReads) { 831 VerifyObject(result); 832 } 833 return result; 834 } 835 836 template<class T, VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 837 inline T* Object::GetFieldObjectVolatile(MemberOffset field_offset) { 838 return GetFieldObject<T, kVerifyFlags, kReadBarrierOption, true>(field_offset); 839 } 840 841 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 842 bool kIsVolatile> 843 inline void Object::SetFieldObjectWithoutWriteBarrier(MemberOffset field_offset, 844 Object* new_value) { 845 if (kCheckTransaction) { 846 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 847 } 848 if (kTransactionActive) { 849 mirror::Object* obj; 850 if (kIsVolatile) { 851 obj = GetFieldObjectVolatile<Object>(field_offset); 852 } else { 853 obj = GetFieldObject<Object>(field_offset); 854 } 855 Runtime::Current()->RecordWriteFieldReference(this, field_offset, obj, true); 856 } 857 if (kVerifyFlags & kVerifyThis) { 858 VerifyObject(this); 859 } 860 if (kVerifyFlags & kVerifyWrites) { 861 VerifyObject(new_value); 862 } 863 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 864 HeapReference<Object>* objref_addr = reinterpret_cast<HeapReference<Object>*>(raw_addr); 865 if (kIsVolatile) { 866 // TODO: Refactor to use a SequentiallyConsistent store instead. 867 QuasiAtomic::ThreadFenceRelease(); // Ensure that prior accesses are visible before store. 868 objref_addr->Assign(new_value); 869 QuasiAtomic::ThreadFenceSequentiallyConsistent(); 870 // Ensure this store occurs before any volatile loads. 871 } else { 872 objref_addr->Assign(new_value); 873 } 874 } 875 876 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags, 877 bool kIsVolatile> 878 inline void Object::SetFieldObject(MemberOffset field_offset, Object* new_value) { 879 SetFieldObjectWithoutWriteBarrier<kTransactionActive, kCheckTransaction, kVerifyFlags, 880 kIsVolatile>(field_offset, new_value); 881 if (new_value != nullptr) { 882 Runtime::Current()->GetHeap()->WriteBarrierField(this, field_offset, new_value); 883 // TODO: Check field assignment could theoretically cause thread suspension, TODO: fix this. 884 CheckFieldAssignment(field_offset, new_value); 885 } 886 } 887 888 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 889 inline void Object::SetFieldObjectVolatile(MemberOffset field_offset, Object* new_value) { 890 SetFieldObject<kTransactionActive, kCheckTransaction, kVerifyFlags, true>(field_offset, 891 new_value); 892 } 893 894 template <VerifyObjectFlags kVerifyFlags> 895 inline HeapReference<Object>* Object::GetFieldObjectReferenceAddr(MemberOffset field_offset) { 896 if (kVerifyFlags & kVerifyThis) { 897 VerifyObject(this); 898 } 899 return reinterpret_cast<HeapReference<Object>*>(reinterpret_cast<uint8_t*>(this) + 900 field_offset.Int32Value()); 901 } 902 903 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 904 inline bool Object::CasFieldWeakSequentiallyConsistentObject(MemberOffset field_offset, 905 Object* old_value, Object* new_value) { 906 bool success = CasFieldWeakSequentiallyConsistentObjectWithoutWriteBarrier< 907 kTransactionActive, kCheckTransaction, kVerifyFlags>(field_offset, old_value, new_value); 908 if (success) { 909 Runtime::Current()->GetHeap()->WriteBarrierField(this, field_offset, new_value); 910 } 911 return success; 912 } 913 914 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 915 inline bool Object::CasFieldWeakSequentiallyConsistentObjectWithoutWriteBarrier( 916 MemberOffset field_offset, Object* old_value, Object* new_value) { 917 if (kCheckTransaction) { 918 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 919 } 920 if (kVerifyFlags & kVerifyThis) { 921 VerifyObject(this); 922 } 923 if (kVerifyFlags & kVerifyWrites) { 924 VerifyObject(new_value); 925 } 926 if (kVerifyFlags & kVerifyReads) { 927 VerifyObject(old_value); 928 } 929 if (kTransactionActive) { 930 Runtime::Current()->RecordWriteFieldReference(this, field_offset, old_value, true); 931 } 932 HeapReference<Object> old_ref(HeapReference<Object>::FromMirrorPtr(old_value)); 933 HeapReference<Object> new_ref(HeapReference<Object>::FromMirrorPtr(new_value)); 934 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 935 Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); 936 937 bool success = atomic_addr->CompareExchangeWeakSequentiallyConsistent(old_ref.reference_, 938 new_ref.reference_); 939 return success; 940 } 941 942 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 943 inline bool Object::CasFieldStrongSequentiallyConsistentObject(MemberOffset field_offset, 944 Object* old_value, Object* new_value) { 945 bool success = CasFieldStrongSequentiallyConsistentObjectWithoutWriteBarrier< 946 kTransactionActive, kCheckTransaction, kVerifyFlags>(field_offset, old_value, new_value); 947 if (success) { 948 Runtime::Current()->GetHeap()->WriteBarrierField(this, field_offset, new_value); 949 } 950 return success; 951 } 952 953 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 954 inline bool Object::CasFieldStrongSequentiallyConsistentObjectWithoutWriteBarrier( 955 MemberOffset field_offset, Object* old_value, Object* new_value) { 956 if (kCheckTransaction) { 957 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 958 } 959 if (kVerifyFlags & kVerifyThis) { 960 VerifyObject(this); 961 } 962 if (kVerifyFlags & kVerifyWrites) { 963 VerifyObject(new_value); 964 } 965 if (kVerifyFlags & kVerifyReads) { 966 VerifyObject(old_value); 967 } 968 if (kTransactionActive) { 969 Runtime::Current()->RecordWriteFieldReference(this, field_offset, old_value, true); 970 } 971 HeapReference<Object> old_ref(HeapReference<Object>::FromMirrorPtr(old_value)); 972 HeapReference<Object> new_ref(HeapReference<Object>::FromMirrorPtr(new_value)); 973 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 974 Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); 975 976 bool success = atomic_addr->CompareExchangeStrongSequentiallyConsistent(old_ref.reference_, 977 new_ref.reference_); 978 return success; 979 } 980 981 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 982 inline bool Object::CasFieldWeakRelaxedObjectWithoutWriteBarrier( 983 MemberOffset field_offset, Object* old_value, Object* new_value) { 984 if (kCheckTransaction) { 985 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 986 } 987 if (kVerifyFlags & kVerifyThis) { 988 VerifyObject(this); 989 } 990 if (kVerifyFlags & kVerifyWrites) { 991 VerifyObject(new_value); 992 } 993 if (kVerifyFlags & kVerifyReads) { 994 VerifyObject(old_value); 995 } 996 if (kTransactionActive) { 997 Runtime::Current()->RecordWriteFieldReference(this, field_offset, old_value, true); 998 } 999 HeapReference<Object> old_ref(HeapReference<Object>::FromMirrorPtr(old_value)); 1000 HeapReference<Object> new_ref(HeapReference<Object>::FromMirrorPtr(new_value)); 1001 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 1002 Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); 1003 1004 bool success = atomic_addr->CompareExchangeWeakRelaxed(old_ref.reference_, 1005 new_ref.reference_); 1006 return success; 1007 } 1008 1009 template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags> 1010 inline bool Object::CasFieldStrongRelaxedObjectWithoutWriteBarrier( 1011 MemberOffset field_offset, Object* old_value, Object* new_value) { 1012 if (kCheckTransaction) { 1013 DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction()); 1014 } 1015 if (kVerifyFlags & kVerifyThis) { 1016 VerifyObject(this); 1017 } 1018 if (kVerifyFlags & kVerifyWrites) { 1019 VerifyObject(new_value); 1020 } 1021 if (kVerifyFlags & kVerifyReads) { 1022 VerifyObject(old_value); 1023 } 1024 if (kTransactionActive) { 1025 Runtime::Current()->RecordWriteFieldReference(this, field_offset, old_value, true); 1026 } 1027 HeapReference<Object> old_ref(HeapReference<Object>::FromMirrorPtr(old_value)); 1028 HeapReference<Object> new_ref(HeapReference<Object>::FromMirrorPtr(new_value)); 1029 uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value(); 1030 Atomic<uint32_t>* atomic_addr = reinterpret_cast<Atomic<uint32_t>*>(raw_addr); 1031 1032 bool success = atomic_addr->CompareExchangeStrongRelaxed(old_ref.reference_, 1033 new_ref.reference_); 1034 return success; 1035 } 1036 1037 template<bool kIsStatic, 1038 VerifyObjectFlags kVerifyFlags, 1039 ReadBarrierOption kReadBarrierOption, 1040 typename Visitor> 1041 inline void Object::VisitFieldsReferences(uint32_t ref_offsets, const Visitor& visitor) { 1042 if (!kIsStatic && (ref_offsets != mirror::Class::kClassWalkSuper)) { 1043 // Instance fields and not the slow-path. 1044 uint32_t field_offset = mirror::kObjectHeaderSize; 1045 while (ref_offsets != 0) { 1046 if ((ref_offsets & 1) != 0) { 1047 visitor(this, MemberOffset(field_offset), kIsStatic); 1048 } 1049 ref_offsets >>= 1; 1050 field_offset += sizeof(mirror::HeapReference<mirror::Object>); 1051 } 1052 } else { 1053 // There is no reference offset bitmap. In the non-static case, walk up the class 1054 // inheritance hierarchy and find reference offsets the hard way. In the static case, just 1055 // consider this class. 1056 for (mirror::Class* klass = kIsStatic 1057 ? AsClass<kVerifyFlags, kReadBarrierOption>() 1058 : GetClass<kVerifyFlags, kReadBarrierOption>(); 1059 klass != nullptr; 1060 klass = kIsStatic ? nullptr : klass->GetSuperClass<kVerifyFlags, kReadBarrierOption>()) { 1061 const size_t num_reference_fields = 1062 kIsStatic ? klass->NumReferenceStaticFields() : klass->NumReferenceInstanceFields(); 1063 if (num_reference_fields == 0u) { 1064 continue; 1065 } 1066 // Presumably GC can happen when we are cross compiling, it should not cause performance 1067 // problems to do pointer size logic. 1068 MemberOffset field_offset = kIsStatic 1069 ? klass->GetFirstReferenceStaticFieldOffset<kVerifyFlags, kReadBarrierOption>( 1070 Runtime::Current()->GetClassLinker()->GetImagePointerSize()) 1071 : klass->GetFirstReferenceInstanceFieldOffset<kVerifyFlags, kReadBarrierOption>(); 1072 for (size_t i = 0u; i < num_reference_fields; ++i) { 1073 // TODO: Do a simpler check? 1074 if (field_offset.Uint32Value() != ClassOffset().Uint32Value()) { 1075 visitor(this, field_offset, kIsStatic); 1076 } 1077 field_offset = MemberOffset(field_offset.Uint32Value() + 1078 sizeof(mirror::HeapReference<mirror::Object>)); 1079 } 1080 } 1081 } 1082 } 1083 1084 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption, typename Visitor> 1085 inline void Object::VisitInstanceFieldsReferences(mirror::Class* klass, const Visitor& visitor) { 1086 VisitFieldsReferences<false, kVerifyFlags, kReadBarrierOption>( 1087 klass->GetReferenceInstanceOffsets<kVerifyFlags>(), visitor); 1088 } 1089 1090 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption, typename Visitor> 1091 inline void Object::VisitStaticFieldsReferences(mirror::Class* klass, const Visitor& visitor) { 1092 DCHECK(!klass->IsTemp()); 1093 klass->VisitFieldsReferences<true, kVerifyFlags, kReadBarrierOption>(0, visitor); 1094 } 1095 1096 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 1097 inline bool Object::IsClassLoader() { 1098 return GetClass<kVerifyFlags, kReadBarrierOption>()->IsClassLoaderClass(); 1099 } 1100 1101 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 1102 inline mirror::ClassLoader* Object::AsClassLoader() { 1103 DCHECK((IsClassLoader<kVerifyFlags, kReadBarrierOption>())); 1104 return down_cast<mirror::ClassLoader*>(this); 1105 } 1106 1107 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 1108 inline bool Object::IsDexCache() { 1109 return GetClass<kVerifyFlags, kReadBarrierOption>()->IsDexCacheClass(); 1110 } 1111 1112 template<VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption> 1113 inline mirror::DexCache* Object::AsDexCache() { 1114 DCHECK((IsDexCache<kVerifyFlags, kReadBarrierOption>())); 1115 return down_cast<mirror::DexCache*>(this); 1116 } 1117 1118 template <bool kVisitNativeRoots, 1119 VerifyObjectFlags kVerifyFlags, 1120 ReadBarrierOption kReadBarrierOption, 1121 typename Visitor, 1122 typename JavaLangRefVisitor> 1123 inline void Object::VisitReferences(const Visitor& visitor, 1124 const JavaLangRefVisitor& ref_visitor) { 1125 mirror::Class* klass = GetClass<kVerifyFlags, kReadBarrierOption>(); 1126 visitor(this, ClassOffset(), false); 1127 const uint32_t class_flags = klass->GetClassFlags<kVerifyNone>(); 1128 if (LIKELY(class_flags == kClassFlagNormal)) { 1129 DCHECK((!klass->IsVariableSize<kVerifyFlags, kReadBarrierOption>())); 1130 VisitInstanceFieldsReferences<kVerifyFlags, kReadBarrierOption>(klass, visitor); 1131 DCHECK((!klass->IsClassClass<kVerifyFlags, kReadBarrierOption>())); 1132 DCHECK(!klass->IsStringClass()); 1133 DCHECK(!klass->IsClassLoaderClass()); 1134 DCHECK((!klass->IsArrayClass<kVerifyFlags, kReadBarrierOption>())); 1135 } else { 1136 if ((class_flags & kClassFlagNoReferenceFields) == 0) { 1137 DCHECK(!klass->IsStringClass()); 1138 if (class_flags == kClassFlagClass) { 1139 DCHECK((klass->IsClassClass<kVerifyFlags, kReadBarrierOption>())); 1140 mirror::Class* as_klass = AsClass<kVerifyNone, kReadBarrierOption>(); 1141 as_klass->VisitReferences<kVisitNativeRoots, kVerifyFlags, kReadBarrierOption>(klass, 1142 visitor); 1143 } else if (class_flags == kClassFlagObjectArray) { 1144 DCHECK((klass->IsObjectArrayClass<kVerifyFlags, kReadBarrierOption>())); 1145 AsObjectArray<mirror::Object, kVerifyNone, kReadBarrierOption>()->VisitReferences(visitor); 1146 } else if ((class_flags & kClassFlagReference) != 0) { 1147 VisitInstanceFieldsReferences<kVerifyFlags, kReadBarrierOption>(klass, visitor); 1148 ref_visitor(klass, AsReference<kVerifyFlags, kReadBarrierOption>()); 1149 } else if (class_flags == kClassFlagDexCache) { 1150 mirror::DexCache* const dex_cache = AsDexCache<kVerifyFlags, kReadBarrierOption>(); 1151 dex_cache->VisitReferences<kVisitNativeRoots, 1152 kVerifyFlags, 1153 kReadBarrierOption>(klass, visitor); 1154 } else { 1155 mirror::ClassLoader* const class_loader = AsClassLoader<kVerifyFlags, kReadBarrierOption>(); 1156 class_loader->VisitReferences<kVisitNativeRoots, 1157 kVerifyFlags, 1158 kReadBarrierOption>(klass, visitor); 1159 } 1160 } else if (kIsDebugBuild) { 1161 CHECK((!klass->IsClassClass<kVerifyFlags, kReadBarrierOption>())); 1162 CHECK((!klass->IsObjectArrayClass<kVerifyFlags, kReadBarrierOption>())); 1163 // String still has instance fields for reflection purposes but these don't exist in 1164 // actual string instances. 1165 if (!klass->IsStringClass()) { 1166 size_t total_reference_instance_fields = 0; 1167 mirror::Class* super_class = klass; 1168 do { 1169 total_reference_instance_fields += super_class->NumReferenceInstanceFields(); 1170 super_class = super_class->GetSuperClass<kVerifyFlags, kReadBarrierOption>(); 1171 } while (super_class != nullptr); 1172 // The only reference field should be the object's class. This field is handled at the 1173 // beginning of the function. 1174 CHECK_EQ(total_reference_instance_fields, 1u); 1175 } 1176 } 1177 } 1178 } 1179 } // namespace mirror 1180 } // namespace art 1181 1182 #endif // ART_RUNTIME_MIRROR_OBJECT_INL_H_ 1183
