blob: 5b129bf2bacd321a441ed59f1ec62f66b5ca0420 [file] [log] [blame]
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001/*
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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_MIRROR_OBJECT_H_
18#define ART_RUNTIME_MIRROR_OBJECT_H_
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080019
Vladimir Markodb8e62d2016-03-30 16:30:21 +010020#include "base/casts.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070021#include "base/enums.h"
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070022#include "globals.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080023#include "object_reference.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "offsets.h"
Mathieu Chartier4e305412014-02-19 10:54:44 -080025#include "verify_object.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026
27namespace art {
28
Mathieu Chartierc7853442015-03-27 14:35:38 -070029class ArtField;
Mathieu Chartiere401d142015-04-22 13:56:20 -070030class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080031class ImageWriter;
Ian Rogersd9c4fc92013-10-01 19:45:43 -070032class LockWord;
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070033class Monitor;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034struct ObjectOffsets;
35class Thread;
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070036class VoidFunctor;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080037
38namespace mirror {
39
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080040class Array;
41class Class;
Mathieu Chartiere4275c02015-08-06 15:34:15 -070042class ClassLoader;
Vladimir Marko05792b92015-08-03 11:56:49 +010043class DexCache;
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -070044class FinalizerReference;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080045template<class T> class ObjectArray;
46template<class T> class PrimitiveArray;
47typedef PrimitiveArray<uint8_t> BooleanArray;
48typedef PrimitiveArray<int8_t> ByteArray;
49typedef PrimitiveArray<uint16_t> CharArray;
50typedef PrimitiveArray<double> DoubleArray;
51typedef PrimitiveArray<float> FloatArray;
52typedef PrimitiveArray<int32_t> IntArray;
53typedef PrimitiveArray<int64_t> LongArray;
54typedef PrimitiveArray<int16_t> ShortArray;
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -070055class Reference;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080056class String;
57class Throwable;
58
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080059// Fields within mirror objects aren't accessed directly so that the appropriate amount of
60// handshaking is done with GC (for example, read and write barriers). This macro is used to
61// compute an offset for the Set/Get methods defined in Object that can safely access fields.
62#define OFFSET_OF_OBJECT_MEMBER(type, field) \
63 MemberOffset(OFFSETOF_MEMBER(type, field))
64
Mathieu Chartier4e305412014-02-19 10:54:44 -080065// Checks that we don't do field assignments which violate the typing system.
66static constexpr bool kCheckFieldAssignments = false;
Ian Rogers04d7aa92013-03-16 14:29:17 -070067
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070068// Size of Object.
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -070069static constexpr uint32_t kObjectHeaderSize = kUseBrooksReadBarrier ? 16 : 8;
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070070
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080071// C++ mirror of java.lang.Object
Ian Rogers719d1a32014-03-06 12:13:39 -080072class MANAGED LOCKABLE Object {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080073 public:
Mingyao Yang98d1cc82014-05-15 17:02:16 -070074 // The number of vtable entries in java.lang.Object.
75 static constexpr size_t kVTableLength = 11;
76
77 // The size of the java.lang.Class representing a java.lang.Object.
Andreas Gampe542451c2016-07-26 09:02:02 -070078 static uint32_t ClassSize(PointerSize pointer_size);
Mingyao Yang98d1cc82014-05-15 17:02:16 -070079
80 // Size of an instance of java.lang.Object.
81 static constexpr uint32_t InstanceSize() {
82 return sizeof(Object);
83 }
84
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080085 static MemberOffset ClassOffset() {
86 return OFFSET_OF_OBJECT_MEMBER(Object, klass_);
87 }
88
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -070089 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
90 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -070091 ALWAYS_INLINE Class* GetClass() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080092
Mathieu Chartier4e305412014-02-19 10:54:44 -080093 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -070094 void SetClass(Class* new_klass) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080095
Mathieu Chartier36a270a2016-07-28 18:08:51 -070096 // TODO: Clean this up and change to return int32_t
Mathieu Chartier90443472015-07-16 20:32:27 -070097 Object* GetReadBarrierPointer() SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchied70b4a2015-11-17 17:52:15 -080098
Andreas Gampe65b798e2015-04-06 09:35:22 -070099#ifndef USE_BAKER_OR_BROOKS_READ_BARRIER
100 NO_RETURN
101#endif
Mathieu Chartier90443472015-07-16 20:32:27 -0700102 void SetReadBarrierPointer(Object* rb_ptr) SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchied70b4a2015-11-17 17:52:15 -0800103
104 template<bool kCasRelease = false>
Hiroshi Yamauchi723e6ce2015-10-28 20:59:47 -0700105 ALWAYS_INLINE bool AtomicSetReadBarrierPointer(Object* expected_rb_ptr, Object* rb_ptr)
Mathieu Chartier90443472015-07-16 20:32:27 -0700106 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier36a270a2016-07-28 18:08:51 -0700107
108 ALWAYS_INLINE uint32_t GetMarkBit() SHARED_REQUIRES(Locks::mutator_lock_);
109
110 ALWAYS_INLINE bool AtomicSetMarkBit(uint32_t expected_mark_bit, uint32_t mark_bit)
111 SHARED_REQUIRES(Locks::mutator_lock_);
112
Mathieu Chartier90443472015-07-16 20:32:27 -0700113 void AssertReadBarrierPointer() const SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800114
Jeff Haoa3faaf42013-09-03 19:07:00 -0700115 // The verifier treats all interfaces as java.lang.Object and relies on runtime checks in
116 // invoke-interface to detect incompatible interface types.
Mathieu Chartier4e305412014-02-19 10:54:44 -0800117 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700118 bool VerifierInstanceOf(Class* klass) SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800119 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700120 ALWAYS_INLINE bool InstanceOf(Class* klass) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800121
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700122 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
123 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700124 size_t SizeOf() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800125
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700126 Object* Clone(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_)
127 REQUIRES(!Roles::uninterruptible_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800128
Sebastien Hertz69206392015-04-07 15:54:25 +0200129 int32_t IdentityHashCode() const
Mathieu Chartier90443472015-07-16 20:32:27 -0700130 SHARED_REQUIRES(Locks::mutator_lock_)
131 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800132
133 static MemberOffset MonitorOffset() {
134 return OFFSET_OF_OBJECT_MEMBER(Object, monitor_);
135 }
136
Hans Boehmd8434432014-07-11 09:56:07 -0700137 // As_volatile can be false if the mutators are suspended. This is an optimization since it
Mathieu Chartier4d7f61d2014-04-17 14:43:39 -0700138 // avoids the barriers.
Andreas Gampe3b45ef22015-05-26 21:34:09 -0700139 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700140 LockWord GetLockWord(bool as_volatile) SHARED_REQUIRES(Locks::mutator_lock_);
Andreas Gampe3b45ef22015-05-26 21:34:09 -0700141 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700142 void SetLockWord(LockWord new_val, bool as_volatile) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers228602f2014-07-10 02:07:54 -0700143 bool CasLockWordWeakSequentiallyConsistent(LockWord old_val, LockWord new_val)
Mathieu Chartier90443472015-07-16 20:32:27 -0700144 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700145 bool CasLockWordWeakRelaxed(LockWord old_val, LockWord new_val)
Mathieu Chartier90443472015-07-16 20:32:27 -0700146 SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchifed3e2f2015-10-20 11:11:56 -0700147 bool CasLockWordWeakRelease(LockWord old_val, LockWord new_val)
148 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700149 uint32_t GetLockOwnerThreadId();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800150
Mathieu Chartiera704eda2016-07-13 09:53:35 -0700151 // Try to enter the monitor, returns non null if we succeeded.
152 mirror::Object* MonitorTryEnter(Thread* self)
153 EXCLUSIVE_LOCK_FUNCTION()
154 REQUIRES(!Roles::uninterruptible_)
155 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier2d096c92015-10-12 16:18:20 -0700156 mirror::Object* MonitorEnter(Thread* self)
157 EXCLUSIVE_LOCK_FUNCTION()
158 REQUIRES(!Roles::uninterruptible_)
159 SHARED_REQUIRES(Locks::mutator_lock_);
160 bool MonitorExit(Thread* self)
161 REQUIRES(!Roles::uninterruptible_)
162 SHARED_REQUIRES(Locks::mutator_lock_)
Ian Rogers719d1a32014-03-06 12:13:39 -0800163 UNLOCK_FUNCTION();
Mathieu Chartier90443472015-07-16 20:32:27 -0700164 void Notify(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
165 void NotifyAll(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
166 void Wait(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
167 void Wait(Thread* self, int64_t timeout, int32_t nanos) SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800168
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700169 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
170 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700171 bool IsClass() SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700172 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
173 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700174 Class* AsClass() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800175
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800176 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
177 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700178 bool IsObjectArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800179 template<class T,
180 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
181 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700182 ObjectArray<T>* AsObjectArray() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800183
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800184 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
185 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartiere4275c02015-08-06 15:34:15 -0700186 bool IsClassLoader() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800187 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
188 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartiere4275c02015-08-06 15:34:15 -0700189 ClassLoader* AsClassLoader() SHARED_REQUIRES(Locks::mutator_lock_);
190
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800191 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
192 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Vladimir Marko05792b92015-08-03 11:56:49 +0100193 bool IsDexCache() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800194 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
195 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Vladimir Marko05792b92015-08-03 11:56:49 +0100196 DexCache* AsDexCache() SHARED_REQUIRES(Locks::mutator_lock_);
197
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700198 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
199 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700200 bool IsArrayInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700201 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
202 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700203 Array* AsArray() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800204
Mathieu Chartier4e305412014-02-19 10:54:44 -0800205 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700206 BooleanArray* AsBooleanArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800207 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700208 ByteArray* AsByteArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800209 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700210 ByteArray* AsByteSizedArray() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800211
Mathieu Chartier4e305412014-02-19 10:54:44 -0800212 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700213 CharArray* AsCharArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800214 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700215 ShortArray* AsShortArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800216 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700217 ShortArray* AsShortSizedArray() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800218
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800219 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
220 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700221 bool IsIntArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800222 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
223 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700224 IntArray* AsIntArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700225
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800226 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
227 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700228 bool IsLongArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800229 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
230 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700231 LongArray* AsLongArray() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800232
Mathieu Chartier4e305412014-02-19 10:54:44 -0800233 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700234 bool IsFloatArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700235 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700236 FloatArray* AsFloatArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700237
238 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700239 bool IsDoubleArray() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800240 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700241 DoubleArray* AsDoubleArray() SHARED_REQUIRES(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100242
Jeff Hao848f70a2014-01-15 13:49:50 -0800243 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
244 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700245 bool IsString() SHARED_REQUIRES(Locks::mutator_lock_);
Jeff Hao848f70a2014-01-15 13:49:50 -0800246
247 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
248 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700249 String* AsString() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800250
Mathieu Chartier4e305412014-02-19 10:54:44 -0800251 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700252 Throwable* AsThrowable() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800253
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800254 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
255 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700256 bool IsReferenceInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierdfe02f62016-02-01 20:15:11 -0800257 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
258 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mathieu Chartier90443472015-07-16 20:32:27 -0700259 Reference* AsReference() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700260 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700261 bool IsWeakReferenceInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800262 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700263 bool IsSoftReferenceInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800264 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700265 bool IsFinalizerReferenceInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier4e305412014-02-19 10:54:44 -0800266 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700267 FinalizerReference* AsFinalizerReference() SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700268 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mathieu Chartier90443472015-07-16 20:32:27 -0700269 bool IsPhantomReferenceInstance() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800270
Ian Rogersef7d42f2014-01-06 12:55:46 -0800271 // Accessor for Java type fields.
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700272 template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700273 ReadBarrierOption kReadBarrierOption = kWithReadBarrier, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700274 ALWAYS_INLINE T* GetFieldObject(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700275 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700276
277 template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
Hiroshi Yamauchi6e83c172014-05-01 21:25:41 -0700278 ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700279 ALWAYS_INLINE T* GetFieldObjectVolatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700280 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700281
282 template<bool kTransactionActive, bool kCheckTransaction = true,
283 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700284 ALWAYS_INLINE void SetFieldObjectWithoutWriteBarrier(MemberOffset field_offset, Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700285 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700286
287 template<bool kTransactionActive, bool kCheckTransaction = true,
288 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700289 ALWAYS_INLINE void SetFieldObject(MemberOffset field_offset, Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700290 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700291
Mathieu Chartier4e305412014-02-19 10:54:44 -0800292 template<bool kTransactionActive, bool kCheckTransaction = true,
293 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700294 ALWAYS_INLINE void SetFieldObjectVolatile(MemberOffset field_offset, Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700295 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700296
Mathieu Chartier4e305412014-02-19 10:54:44 -0800297 template<bool kTransactionActive, bool kCheckTransaction = true,
298 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Ian Rogers228602f2014-07-10 02:07:54 -0700299 bool CasFieldWeakSequentiallyConsistentObject(MemberOffset field_offset, Object* old_value,
300 Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700301 SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800302 template<bool kTransactionActive, bool kCheckTransaction = true,
303 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
304 bool CasFieldWeakSequentiallyConsistentObjectWithoutWriteBarrier(MemberOffset field_offset,
305 Object* old_value,
306 Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700307 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700308 template<bool kTransactionActive, bool kCheckTransaction = true,
309 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
310 bool CasFieldStrongSequentiallyConsistentObject(MemberOffset field_offset, Object* old_value,
311 Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700312 SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800313 template<bool kTransactionActive, bool kCheckTransaction = true,
314 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
315 bool CasFieldStrongSequentiallyConsistentObjectWithoutWriteBarrier(MemberOffset field_offset,
316 Object* old_value,
317 Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700318 SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchifed3e2f2015-10-20 11:11:56 -0700319 template<bool kTransactionActive, bool kCheckTransaction = true,
320 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
321 bool CasFieldWeakRelaxedObjectWithoutWriteBarrier(MemberOffset field_offset,
322 Object* old_value,
323 Object* new_value)
324 SHARED_REQUIRES(Locks::mutator_lock_);
325 template<bool kTransactionActive, bool kCheckTransaction = true,
326 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
327 bool CasFieldStrongRelaxedObjectWithoutWriteBarrier(MemberOffset field_offset,
328 Object* old_value,
329 Object* new_value)
330 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700331
Mathieu Chartier4e305412014-02-19 10:54:44 -0800332 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
333 HeapReference<Object>* GetFieldObjectReferenceAddr(MemberOffset field_offset);
Mathieu Chartier11409ae2013-09-23 11:49:36 -0700334
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700335 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Fred Shih37f05ef2014-07-16 18:38:08 -0700336 ALWAYS_INLINE uint8_t GetFieldBoolean(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700337 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700338
339 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
340 ALWAYS_INLINE int8_t GetFieldByte(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700341 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700342
343 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
344 ALWAYS_INLINE uint8_t GetFieldBooleanVolatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700345 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700346
347 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
348 ALWAYS_INLINE int8_t GetFieldByteVolatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700349 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700350
351 template<bool kTransactionActive, bool kCheckTransaction = true,
352 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
353 ALWAYS_INLINE void SetFieldBoolean(MemberOffset field_offset, uint8_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700354 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700355
356 template<bool kTransactionActive, bool kCheckTransaction = true,
357 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
358 ALWAYS_INLINE void SetFieldByte(MemberOffset field_offset, int8_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700359 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700360
361 template<bool kTransactionActive, bool kCheckTransaction = true,
362 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
363 ALWAYS_INLINE void SetFieldBooleanVolatile(MemberOffset field_offset, uint8_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700364 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700365
366 template<bool kTransactionActive, bool kCheckTransaction = true,
367 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
368 ALWAYS_INLINE void SetFieldByteVolatile(MemberOffset field_offset, int8_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700369 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700370
371 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
372 ALWAYS_INLINE uint16_t GetFieldChar(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700373 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700374
375 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
376 ALWAYS_INLINE int16_t GetFieldShort(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700377 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700378
379 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
380 ALWAYS_INLINE uint16_t GetFieldCharVolatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700381 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700382
383 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
384 ALWAYS_INLINE int16_t GetFieldShortVolatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700385 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700386
387 template<bool kTransactionActive, bool kCheckTransaction = true,
388 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
389 ALWAYS_INLINE void SetFieldChar(MemberOffset field_offset, uint16_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700390 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700391
392 template<bool kTransactionActive, bool kCheckTransaction = true,
393 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
394 ALWAYS_INLINE void SetFieldShort(MemberOffset field_offset, int16_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700395 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700396
397 template<bool kTransactionActive, bool kCheckTransaction = true,
398 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
399 ALWAYS_INLINE void SetFieldCharVolatile(MemberOffset field_offset, uint16_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700400 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700401
402 template<bool kTransactionActive, bool kCheckTransaction = true,
403 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
404 ALWAYS_INLINE void SetFieldShortVolatile(MemberOffset field_offset, int16_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700405 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700406
407 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700408 ALWAYS_INLINE int32_t GetField32(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700409 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700410
Mathieu Chartier4e305412014-02-19 10:54:44 -0800411 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700412 ALWAYS_INLINE int32_t GetField32Volatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700413 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700414
415 template<bool kTransactionActive, bool kCheckTransaction = true,
416 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700417 ALWAYS_INLINE void SetField32(MemberOffset field_offset, int32_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700418 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700419
Mathieu Chartier4e305412014-02-19 10:54:44 -0800420 template<bool kTransactionActive, bool kCheckTransaction = true,
421 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700422 ALWAYS_INLINE void SetField32Volatile(MemberOffset field_offset, int32_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700423 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700424
425 template<bool kTransactionActive, bool kCheckTransaction = true,
426 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700427 ALWAYS_INLINE bool CasFieldWeakSequentiallyConsistent32(MemberOffset field_offset,
428 int32_t old_value, int32_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700429 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700430
Hans Boehmd8434432014-07-11 09:56:07 -0700431 template<bool kTransactionActive, bool kCheckTransaction = true,
432 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
433 bool CasFieldWeakRelaxed32(MemberOffset field_offset, int32_t old_value,
434 int32_t new_value) ALWAYS_INLINE
Mathieu Chartier90443472015-07-16 20:32:27 -0700435 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700436
437 template<bool kTransactionActive, bool kCheckTransaction = true,
438 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Hiroshi Yamauchifed3e2f2015-10-20 11:11:56 -0700439 bool CasFieldWeakRelease32(MemberOffset field_offset, int32_t old_value,
440 int32_t new_value) ALWAYS_INLINE
441 SHARED_REQUIRES(Locks::mutator_lock_);
442
443 template<bool kTransactionActive, bool kCheckTransaction = true,
444 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Hans Boehmd8434432014-07-11 09:56:07 -0700445 bool CasFieldStrongSequentiallyConsistent32(MemberOffset field_offset, int32_t old_value,
446 int32_t new_value) ALWAYS_INLINE
Mathieu Chartier90443472015-07-16 20:32:27 -0700447 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700448
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700449 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700450 ALWAYS_INLINE int64_t GetField64(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700451 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700452
453 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700454 ALWAYS_INLINE int64_t GetField64Volatile(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700455 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700456
457 template<bool kTransactionActive, bool kCheckTransaction = true,
458 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700459 ALWAYS_INLINE void SetField64(MemberOffset field_offset, int64_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700460 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700461
462 template<bool kTransactionActive, bool kCheckTransaction = true,
463 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700464 ALWAYS_INLINE void SetField64Volatile(MemberOffset field_offset, int64_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700465 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800466
Mathieu Chartier4e305412014-02-19 10:54:44 -0800467 template<bool kTransactionActive, bool kCheckTransaction = true,
468 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Ian Rogers228602f2014-07-10 02:07:54 -0700469 bool CasFieldWeakSequentiallyConsistent64(MemberOffset field_offset, int64_t old_value,
470 int64_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700471 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800472
Mathieu Chartier4e305412014-02-19 10:54:44 -0800473 template<bool kTransactionActive, bool kCheckTransaction = true,
Hans Boehmd8434432014-07-11 09:56:07 -0700474 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
475 bool CasFieldStrongSequentiallyConsistent64(MemberOffset field_offset, int64_t old_value,
476 int64_t new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700477 SHARED_REQUIRES(Locks::mutator_lock_);
Hans Boehmd8434432014-07-11 09:56:07 -0700478
479 template<bool kTransactionActive, bool kCheckTransaction = true,
Mathieu Chartier4e305412014-02-19 10:54:44 -0800480 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename T>
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700481 void SetFieldPtr(MemberOffset field_offset, T new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700482 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800483 SetFieldPtrWithSize<kTransactionActive, kCheckTransaction, kVerifyFlags>(
Andreas Gampe542451c2016-07-26 09:02:02 -0700484 field_offset, new_value, kRuntimePointerSize);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800485 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800486 template<bool kTransactionActive, bool kCheckTransaction = true,
487 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename T>
488 void SetFieldPtr64(MemberOffset field_offset, T new_value)
489 SHARED_REQUIRES(Locks::mutator_lock_) {
490 SetFieldPtrWithSize<kTransactionActive, kCheckTransaction, kVerifyFlags>(
491 field_offset, new_value, 8u);
492 }
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800493
Mathieu Chartier2d721012014-11-10 11:08:06 -0800494 template<bool kTransactionActive, bool kCheckTransaction = true,
495 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, typename T>
Andreas Gampe542451c2016-07-26 09:02:02 -0700496 ALWAYS_INLINE void SetFieldPtrWithSize(MemberOffset field_offset,
497 T new_value,
498 PointerSize pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700499 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe542451c2016-07-26 09:02:02 -0700500 if (pointer_size == PointerSize::k32) {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800501 intptr_t ptr = reinterpret_cast<intptr_t>(new_value);
502 DCHECK_EQ(static_cast<int32_t>(ptr), ptr); // Check that we dont lose any non 0 bits.
503 SetField32<kTransactionActive, kCheckTransaction, kVerifyFlags>(
504 field_offset, static_cast<int32_t>(ptr));
505 } else {
506 SetField64<kTransactionActive, kCheckTransaction, kVerifyFlags>(
Vladimir Markodb8e62d2016-03-30 16:30:21 +0100507 field_offset, reinterpret_cast64<int64_t>(new_value));
Mathieu Chartier2d721012014-11-10 11:08:06 -0800508 }
509 }
Mathieu Chartier407f7022014-02-18 14:37:05 -0800510 // TODO fix thread safety analysis broken by the use of template. This should be
Mathieu Chartier90443472015-07-16 20:32:27 -0700511 // SHARED_REQUIRES(Locks::mutator_lock_).
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800512 template <bool kVisitNativeRoots = true,
513 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
514 ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
Mathieu Chartier059ef3d2015-08-18 13:54:21 -0700515 typename Visitor,
516 typename JavaLangRefVisitor = VoidFunctor>
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700517 void VisitReferences(const Visitor& visitor, const JavaLangRefVisitor& ref_visitor)
Mathieu Chartier407f7022014-02-18 14:37:05 -0800518 NO_THREAD_SAFETY_ANALYSIS;
519
Mathieu Chartier90443472015-07-16 20:32:27 -0700520 ArtField* FindFieldByOffset(MemberOffset offset) SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchieb2baaf2015-05-13 21:14:22 -0700521
tony.ys_liu7380c312015-01-16 19:16:45 +0800522 // Used by object_test.
523 static void SetHashCodeSeed(uint32_t new_seed);
524 // Generate an identity hash code. Public for object test.
525 static uint32_t GenerateIdentityHashCode();
526
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800527 protected:
528 // Accessors for non-Java type fields
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700529 template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
530 T GetFieldPtr(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700531 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe542451c2016-07-26 09:02:02 -0700532 return GetFieldPtrWithSize<T, kVerifyFlags, kIsVolatile>(field_offset, kRuntimePointerSize);
Mathieu Chartier2d721012014-11-10 11:08:06 -0800533 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800534 template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
535 T GetFieldPtr64(MemberOffset field_offset)
536 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe542451c2016-07-26 09:02:02 -0700537 return GetFieldPtrWithSize<T, kVerifyFlags, kIsVolatile>(field_offset,
538 PointerSize::k64);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800539 }
Mathieu Chartier2d721012014-11-10 11:08:06 -0800540
541 template<class T, VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, bool kIsVolatile = false>
Andreas Gampe542451c2016-07-26 09:02:02 -0700542 ALWAYS_INLINE T GetFieldPtrWithSize(MemberOffset field_offset, PointerSize pointer_size)
Mathieu Chartier90443472015-07-16 20:32:27 -0700543 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe542451c2016-07-26 09:02:02 -0700544 if (pointer_size == PointerSize::k32) {
Mathieu Chartier2d721012014-11-10 11:08:06 -0800545 return reinterpret_cast<T>(GetField32<kVerifyFlags, kIsVolatile>(field_offset));
546 } else {
547 int64_t v = GetField64<kVerifyFlags, kIsVolatile>(field_offset);
Vladimir Markodb8e62d2016-03-30 16:30:21 +0100548 return reinterpret_cast64<T>(v);
Mathieu Chartier2d721012014-11-10 11:08:06 -0800549 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800550 }
551
Mathieu Chartier407f7022014-02-18 14:37:05 -0800552 // TODO: Fixme when anotatalysis works with visitors.
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800553 template<bool kIsStatic,
554 VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
555 ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
556 typename Visitor>
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700557 void VisitFieldsReferences(uint32_t ref_offsets, const Visitor& visitor) HOT_ATTR
Mathieu Chartier407f7022014-02-18 14:37:05 -0800558 NO_THREAD_SAFETY_ANALYSIS;
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800559 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
560 ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
561 typename Visitor>
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700562 void VisitInstanceFieldsReferences(mirror::Class* klass, const Visitor& visitor) HOT_ATTR
Mathieu Chartier90443472015-07-16 20:32:27 -0700563 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800564 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
565 ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
566 typename Visitor>
Ian Rogersb0fa5dc2014-04-28 16:47:08 -0700567 void VisitStaticFieldsReferences(mirror::Class* klass, const Visitor& visitor) HOT_ATTR
Mathieu Chartier90443472015-07-16 20:32:27 -0700568 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier407f7022014-02-18 14:37:05 -0800569
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800570 private:
Fred Shih37f05ef2014-07-16 18:38:08 -0700571 template<typename kSize, bool kIsVolatile>
572 ALWAYS_INLINE void SetField(MemberOffset field_offset, kSize new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700573 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700574 template<typename kSize, bool kIsVolatile>
575 ALWAYS_INLINE kSize GetField(MemberOffset field_offset)
Mathieu Chartier90443472015-07-16 20:32:27 -0700576 SHARED_REQUIRES(Locks::mutator_lock_);
Fred Shih37f05ef2014-07-16 18:38:08 -0700577
Ian Rogers04d7aa92013-03-16 14:29:17 -0700578 // Verify the type correctness of stores to fields.
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700579 // TODO: This can cause thread suspension and isn't moving GC safe.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800580 void CheckFieldAssignmentImpl(MemberOffset field_offset, Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700581 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800582 void CheckFieldAssignment(MemberOffset field_offset, Object* new_value)
Mathieu Chartier90443472015-07-16 20:32:27 -0700583 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers04d7aa92013-03-16 14:29:17 -0700584 if (kCheckFieldAssignments) {
585 CheckFieldAssignmentImpl(field_offset, new_value);
586 }
587 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800588
Hiroshi Yamauchi0fbd6e62014-07-17 16:16:31 -0700589 // A utility function that copies an object in a read barrier and
590 // write barrier-aware way. This is internally used by Clone() and
591 // Class::CopyOf().
592 static Object* CopyObject(Thread* self, mirror::Object* dest, mirror::Object* src,
593 size_t num_bytes)
Mathieu Chartier90443472015-07-16 20:32:27 -0700594 SHARED_REQUIRES(Locks::mutator_lock_);
Hiroshi Yamauchi0fbd6e62014-07-17 16:16:31 -0700595
tony.ys_liu7380c312015-01-16 19:16:45 +0800596 static Atomic<uint32_t> hash_code_seed;
597
Ian Rogersef7d42f2014-01-06 12:55:46 -0800598 // The Class representing the type of the object.
599 HeapReference<Class> klass_;
600 // Monitor and hash code information.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800601 uint32_t monitor_;
602
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -0700603#ifdef USE_BROOKS_READ_BARRIER
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -0700604 // Note names use a 'x' prefix and the x_rb_ptr_ is of type int
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800605 // instead of Object to go with the alphabetical/by-type field order
606 // on the Java side.
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -0700607 uint32_t x_rb_ptr_; // For the Brooks pointer.
Hiroshi Yamauchi624468c2014-03-31 15:14:47 -0700608 uint32_t x_xpadding_; // For 8-byte alignment. TODO: get rid of this.
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800609#endif
610
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800611 friend class art::ImageWriter;
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700612 friend class art::Monitor;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800613 friend struct art::ObjectOffsets; // for verifying offset information
Hiroshi Yamauchi0fbd6e62014-07-17 16:16:31 -0700614 friend class CopyObjectVisitor; // for CopyObject().
615 friend class CopyClassVisitor; // for CopyObject().
Ian Rogerscf7f1912014-10-22 22:06:39 -0700616 DISALLOW_ALLOCATION();
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800617 DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
618};
619
620} // namespace mirror
621} // namespace art
622
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700623#endif // ART_RUNTIME_MIRROR_OBJECT_H_