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_H_
18 #define ART_RUNTIME_MIRROR_OBJECT_H_
19 
20 #include "object_reference.h"
21 #include "offsets.h"
22 #include "verify_object.h"
23 
24 namespace art {
25 
26 class ImageWriter;
27 class LockWord;
28 class Monitor;
29 struct ObjectOffsets;
30 class Thread;
31 class VoidFunctor;
32 
33 namespace mirror {
34 
35 class ArtField;
36 class ArtMethod;
37 class Array;
38 class Class;
39 class FinalizerReference;
40 template<class T> class ObjectArray;
41 template<class T> class PrimitiveArray;
42 typedef PrimitiveArray<uint8_t> BooleanArray;
43 typedef PrimitiveArray<int8_t> ByteArray;
44 typedef PrimitiveArray<uint16_t> CharArray;
45 typedef PrimitiveArray<double> DoubleArray;
46 typedef PrimitiveArray<float> FloatArray;
47 typedef PrimitiveArray<int32_t> IntArray;
48 typedef PrimitiveArray<int64_t> LongArray;
49 typedef PrimitiveArray<int16_t> ShortArray;
50 class Reference;
51 class String;
52 class Throwable;
53 
54 // Fields within mirror objects aren't accessed directly so that the appropriate amount of
55 // handshaking is done with GC (for example, read and write barriers). This macro is used to
56 // compute an offset for the Set/Get methods defined in Object that can safely access fields.
57 #define OFFSET_OF_OBJECT_MEMBER(type, field) \
58     MemberOffset(OFFSETOF_MEMBER(type, field))
59 
60 // Checks that we don't do field assignments which violate the typing system.
61 static constexpr bool kCheckFieldAssignments = false;
62 
63 // C++ mirror of java.lang.Object
64 class MANAGED LOCKABLE Object {
65  public:
66   // The number of vtable entries in java.lang.Object.
67   static constexpr size_t kVTableLength = 11;
68 
69   // The size of the java.lang.Class representing a java.lang.Object.
70   static uint32_t ClassSize();
71 
72   // Size of an instance of java.lang.Object.
InstanceSize()73   static constexpr uint32_t InstanceSize() {
74     return sizeof(Object);
75   }
76 
ClassOffset()77   static MemberOffset ClassOffset() {
78     return OFFSET_OF_OBJECT_MEMBER(Object, klass_);
79   }
80 
81   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
82            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
83   ALWAYS_INLINE Class* GetClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
84 
85   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
86   void SetClass(Class* new_klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
87 
88   Object* GetReadBarrierPointer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
89   void SetReadBarrierPointer(Object* rb_ptr) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
90   bool AtomicSetReadBarrierPointer(Object* expected_rb_ptr, Object* rb_ptr)
91       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
92   void AssertReadBarrierPointer() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
93 
94   // The verifier treats all interfaces as java.lang.Object and relies on runtime checks in
95   // invoke-interface to detect incompatible interface types.
96   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
97   bool VerifierInstanceOf(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
98   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
99   bool InstanceOf(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
100 
101   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
102            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
103   size_t SizeOf() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
104 
105   Object* Clone(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
106 
107   int32_t IdentityHashCode() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
108 
MonitorOffset()109   static MemberOffset MonitorOffset() {
110     return OFFSET_OF_OBJECT_MEMBER(Object, monitor_);
111   }
112 
113   // As_volatile can be false if the mutators are suspended. This is an optimization since it
114   // avoids the barriers.
115   LockWord GetLockWord(bool as_volatile) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
116   void SetLockWord(LockWord new_val, bool as_volatile) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
117   bool CasLockWordWeakSequentiallyConsistent(LockWord old_val, LockWord new_val)
118       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
119   bool CasLockWordWeakRelaxed(LockWord old_val, LockWord new_val)
120       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
121   uint32_t GetLockOwnerThreadId();
122 
123   mirror::Object* MonitorEnter(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
124       EXCLUSIVE_LOCK_FUNCTION();
125   bool MonitorExit(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
126       UNLOCK_FUNCTION();
127   void Notify(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
128   void NotifyAll(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
129   void Wait(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
130   void Wait(Thread* self, int64_t timeout, int32_t nanos) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
131 
132   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
133            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
134   bool IsClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
135   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
136            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
137   Class* AsClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
138 
139   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
140   bool IsObjectArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
141   template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
142   ObjectArray<T>* AsObjectArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
143 
144   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
145            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
146   bool IsArrayInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
147   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
148            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
149   Array* AsArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
150 
151   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
152   BooleanArray* AsBooleanArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
153   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
154   ByteArray* AsByteArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
155   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
156   ByteArray* AsByteSizedArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
157 
158   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
159   CharArray* AsCharArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
160   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
161   ShortArray* AsShortArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
162   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
163   ShortArray* AsShortSizedArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
164 
165   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
166   IntArray* AsIntArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
167   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
168   LongArray* AsLongArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
169 
170   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
171   FloatArray* AsFloatArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
172   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
173   DoubleArray* AsDoubleArray() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
174 
175   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
176   String* AsString() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
177 
178   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
179   Throwable* AsThrowable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
180 
181   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
182            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
183   bool IsArtMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
184   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
185   ArtMethod* AsArtMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
186 
187   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
188            ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
189   bool IsArtField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
190   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
191   ArtField* AsArtField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
192 
193   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
194   bool IsReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
195   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
196   Reference* AsReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
197   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
198   bool IsWeakReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
199   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
200   bool IsSoftReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
201   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
202   bool IsFinalizerReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
203   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
204   FinalizerReference* AsFinalizerReference() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
205   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
206   bool IsPhantomReferenceInstance() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
207 
208   // Accessor for Java type fields.
209   template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
210       ReadBarrierOption kReadBarrierOption = kWithReadBarrier, bool kIsVolatile = false>
211   ALWAYS_INLINE T* GetFieldObject(MemberOffset field_offset)
212       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
213 
214   template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
215       ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
216   ALWAYS_INLINE T* GetFieldObjectVolatile(MemberOffset field_offset)
217       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
218 
219   template<bool kTransactionActive, bool kCheckTransaction = true,
220       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
221   ALWAYS_INLINE void SetFieldObjectWithoutWriteBarrier(MemberOffset field_offset, Object* new_value)
222       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
223 
224   template<bool kTransactionActive, bool kCheckTransaction = true,
225       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
226   ALWAYS_INLINE void SetFieldObject(MemberOffset field_offset, Object* new_value)
227       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
228 
229   template<bool kTransactionActive, bool kCheckTransaction = true,
230       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
231   ALWAYS_INLINE void SetFieldObjectVolatile(MemberOffset field_offset, Object* new_value)
232       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
233 
234   template<bool kTransactionActive, bool kCheckTransaction = true,
235       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
236   bool CasFieldWeakSequentiallyConsistentObject(MemberOffset field_offset, Object* old_value,
237                                                 Object* new_value)
238       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
239 
240   template<bool kTransactionActive, bool kCheckTransaction = true,
241       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
242   bool CasFieldStrongSequentiallyConsistentObject(MemberOffset field_offset, Object* old_value,
243                                                   Object* new_value)
244       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
245 
246   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
247   HeapReference<Object>* GetFieldObjectReferenceAddr(MemberOffset field_offset);
248 
249   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
250   ALWAYS_INLINE int32_t GetField32(MemberOffset field_offset)
251       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
252 
253   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
254   ALWAYS_INLINE int32_t GetField32Volatile(MemberOffset field_offset)
255       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
256 
257   template<bool kTransactionActive, bool kCheckTransaction = true,
258       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
259   ALWAYS_INLINE void SetField32(MemberOffset field_offset, int32_t new_value)
260       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
261 
262   template<bool kTransactionActive, bool kCheckTransaction = true,
263       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
264   ALWAYS_INLINE void SetField32Volatile(MemberOffset field_offset, int32_t new_value)
265       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
266 
267   template<bool kTransactionActive, bool kCheckTransaction = true,
268       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
269   ALWAYS_INLINE bool CasFieldWeakSequentiallyConsistent32(MemberOffset field_offset,
270                                                           int32_t old_value, int32_t new_value)
271       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
272 
273   template<bool kTransactionActive, bool kCheckTransaction = true,
274       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
275   bool CasFieldWeakRelaxed32(MemberOffset field_offset, int32_t old_value,
276                              int32_t new_value) ALWAYS_INLINE
277       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
278 
279   template<bool kTransactionActive, bool kCheckTransaction = true,
280       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
281   bool CasFieldStrongSequentiallyConsistent32(MemberOffset field_offset, int32_t old_value,
282                                               int32_t new_value) ALWAYS_INLINE
283       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
284 
285   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
286   ALWAYS_INLINE int64_t GetField64(MemberOffset field_offset)
287       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
288 
289   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
290   ALWAYS_INLINE int64_t GetField64Volatile(MemberOffset field_offset)
291       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
292 
293   template<bool kTransactionActive, bool kCheckTransaction = true,
294       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
295   ALWAYS_INLINE void SetField64(MemberOffset field_offset, int64_t new_value)
296       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
297 
298   template<bool kTransactionActive, bool kCheckTransaction = true,
299       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
300   ALWAYS_INLINE void SetField64Volatile(MemberOffset field_offset, int64_t new_value)
301       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
302 
303   template<bool kTransactionActive, bool kCheckTransaction = true,
304       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
305   bool CasFieldWeakSequentiallyConsistent64(MemberOffset field_offset, int64_t old_value,
306                                             int64_t new_value)
307       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
308 
309   template<bool kTransactionActive, bool kCheckTransaction = true,
310       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
311   bool CasFieldStrongSequentiallyConsistent64(MemberOffset field_offset, int64_t old_value,
312                                               int64_t new_value)
313       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
314 
315   template<bool kTransactionActive, bool kCheckTransaction = true,
316       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename T>
SetFieldPtr(MemberOffset field_offset,T new_value)317   void SetFieldPtr(MemberOffset field_offset, T new_value)
318       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
319     SetFieldPtrWithSize<kTransactionActive, kCheckTransaction, kVerifyFlags>(
320         field_offset, new_value, sizeof(void*));
321   }
322 
323   template<bool kTransactionActive, bool kCheckTransaction = true,
324       VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename T>
SetFieldPtrWithSize(MemberOffset field_offset,T new_value,size_t pointer_size)325   ALWAYS_INLINE void SetFieldPtrWithSize(MemberOffset field_offset, T new_value,
326                                          size_t pointer_size)
327       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
328     DCHECK(pointer_size == 4 || pointer_size == 8) << pointer_size;
329     if (pointer_size == 4) {
330       intptr_t ptr  = reinterpret_cast<intptr_t>(new_value);
331       DCHECK_EQ(static_cast<int32_t>(ptr), ptr);  // Check that we dont lose any non 0 bits.
332       SetField32<kTransactionActive, kCheckTransaction, kVerifyFlags>(
333           field_offset, static_cast<int32_t>(ptr));
334     } else {
335       SetField64<kTransactionActive, kCheckTransaction, kVerifyFlags>(
336           field_offset, static_cast<int64_t>(reinterpret_cast<intptr_t>(new_value)));
337     }
338   }
339   // TODO fix thread safety analysis broken by the use of template. This should be
340   // SHARED_LOCKS_REQUIRED(Locks::mutator_lock_).
341   template <const bool kVisitClass, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
342       typename Visitor, typename JavaLangRefVisitor = VoidFunctor>
343   void VisitReferences(const Visitor& visitor, const JavaLangRefVisitor& ref_visitor)
344       NO_THREAD_SAFETY_ANALYSIS;
345 
346   // Used by object_test.
347   static void SetHashCodeSeed(uint32_t new_seed);
348   // Generate an identity hash code. Public for object test.
349   static uint32_t GenerateIdentityHashCode();
350 
351  protected:
352   // Accessors for non-Java type fields
353   template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
GetFieldPtr(MemberOffset field_offset)354   T GetFieldPtr(MemberOffset field_offset)
355       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
356     return GetFieldPtrWithSize<T, kVerifyFlags, kIsVolatile>(field_offset, sizeof(void*));
357   }
358 
359   template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
GetFieldPtrWithSize(MemberOffset field_offset,size_t pointer_size)360   ALWAYS_INLINE T GetFieldPtrWithSize(MemberOffset field_offset, size_t pointer_size)
361       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
362     DCHECK(pointer_size == 4 || pointer_size == 8) << pointer_size;
363     if (pointer_size == 4) {
364       return reinterpret_cast<T>(GetField32<kVerifyFlags, kIsVolatile>(field_offset));
365     } else {
366       int64_t v = GetField64<kVerifyFlags, kIsVolatile>(field_offset);
367       // Check that we dont lose any non 0 bits.
368       DCHECK_EQ(reinterpret_cast<int64_t>(reinterpret_cast<T>(v)), v);
369       return reinterpret_cast<T>(v);
370     }
371   }
372 
373   // TODO: Fixme when anotatalysis works with visitors.
374   template<bool kVisitClass, bool kIsStatic, typename Visitor>
375   void VisitFieldsReferences(uint32_t ref_offsets, const Visitor& visitor) HOT_ATTR
376       NO_THREAD_SAFETY_ANALYSIS;
377   template<bool kVisitClass, typename Visitor>
378   void VisitInstanceFieldsReferences(mirror::Class* klass, const Visitor& visitor) HOT_ATTR
379       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
380   template<bool kVisitClass, typename Visitor>
381   void VisitStaticFieldsReferences(mirror::Class* klass, const Visitor& visitor) HOT_ATTR
382       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
383 
384  private:
385   // Verify the type correctness of stores to fields.
386   // TODO: This can cause thread suspension and isn't moving GC safe.
387   void CheckFieldAssignmentImpl(MemberOffset field_offset, Object* new_value)
388       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
CheckFieldAssignment(MemberOffset field_offset,Object * new_value)389   void CheckFieldAssignment(MemberOffset field_offset, Object* new_value)
390       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
391     if (kCheckFieldAssignments) {
392       CheckFieldAssignmentImpl(field_offset, new_value);
393     }
394   }
395 
396   // A utility function that copies an object in a read barrier and
397   // write barrier-aware way. This is internally used by Clone() and
398   // Class::CopyOf().
399   static Object* CopyObject(Thread* self, mirror::Object* dest, mirror::Object* src,
400                             size_t num_bytes)
401       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
402 
403   static Atomic<uint32_t> hash_code_seed;
404 
405   // The Class representing the type of the object.
406   HeapReference<Class> klass_;
407   // Monitor and hash code information.
408   uint32_t monitor_;
409 
410 #ifdef USE_BAKER_OR_BROOKS_READ_BARRIER
411   // Note names use a 'x' prefix and the x_rb_ptr_ is of type int
412   // instead of Object to go with the alphabetical/by-type field order
413   // on the Java side.
414   uint32_t x_rb_ptr_;      // For the Baker or Brooks pointer.
415   uint32_t x_xpadding_;    // For 8-byte alignment. TODO: get rid of this.
416 #endif
417 
418   friend class art::ImageWriter;
419   friend class art::Monitor;
420   friend struct art::ObjectOffsets;  // for verifying offset information
421   friend class CopyObjectVisitor;  // for CopyObject().
422   friend class CopyClassVisitor;   // for CopyObject().
423   DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
424 };
425 
426 }  // namespace mirror
427 }  // namespace art
428 
429 #endif  // ART_RUNTIME_MIRROR_OBJECT_H_
430