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