1 /**
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #ifndef PANDA_RUNTIME_OBJECT_HEADER_INL_H_
16 #define PANDA_RUNTIME_OBJECT_HEADER_INL_H_
17
18 #include "runtime/include/class-inl.h"
19 #include "runtime/include/field.h"
20 #include "runtime/include/object_accessor-inl.h"
21 #include "runtime/include/object_header.h"
22
23 namespace ark {
24
25 template <MTModeT MT_MODE>
GetHashCode()26 uint32_t ObjectHeader::GetHashCode()
27 {
28 // NOLINTNEXTLINE(readability-braces-around-statements)
29 if constexpr (MT_MODE == MT_MODE_SINGLE) {
30 return GetHashCodeMTSingle();
31 } else { // NOLINT(readability-misleading-indentation)
32 return GetHashCodeMTMulti();
33 }
34 }
35
IsInstanceOf(const Class * klass)36 inline bool ObjectHeader::IsInstanceOf(const Class *klass) const
37 {
38 ASSERT(klass != nullptr);
39 return klass->IsAssignableFrom(ClassAddr<Class>());
40 }
41
42 template <class T, bool IS_VOLATILE> // IS_VOLATILE is false by default
GetFieldPrimitive(size_t offset)43 inline T ObjectHeader::GetFieldPrimitive(size_t offset) const
44 {
45 return ObjectAccessor::GetPrimitive<T, IS_VOLATILE>(this, offset);
46 }
47
48 template <class T, bool IS_VOLATILE> // IS_VOLATILE is false by default
SetFieldPrimitive(size_t offset,T value)49 inline void ObjectHeader::SetFieldPrimitive(size_t offset, T value)
50 {
51 ObjectAccessor::SetPrimitive<T, IS_VOLATILE>(this, offset, value);
52 }
53
54 // IS_VOLATILE is false by default
55 // NEED_WRITE_BARRIER is true by default
56 // IS_DYN is false by default
57 template <bool IS_VOLATILE, bool NEED_READ_BARRIER, bool IS_DYN>
GetFieldObject(int offset)58 inline ObjectHeader *ObjectHeader::GetFieldObject(int offset) const
59 {
60 return ObjectAccessor::GetObject<IS_VOLATILE, NEED_READ_BARRIER, IS_DYN>(this, offset);
61 }
62
63 // IS_VOLATILE is false by default
64 // NEED_WRITE_BARRIER is true by default
65 // IS_DYN is false by default
66 template <bool IS_VOLATILE, bool NEED_WRITE_BARRIER, bool IS_DYN>
SetFieldObject(size_t offset,ObjectHeader * value)67 inline void ObjectHeader::SetFieldObject(size_t offset, ObjectHeader *value)
68 {
69 ObjectAccessor::SetObject<IS_VOLATILE, NEED_WRITE_BARRIER, IS_DYN>(this, offset, value);
70 }
71
72 template <class T>
GetFieldPrimitive(const Field & field)73 inline T ObjectHeader::GetFieldPrimitive(const Field &field) const
74 {
75 return ObjectAccessor::GetFieldPrimitive<T>(this, field);
76 }
77
78 template <class T>
SetFieldPrimitive(const Field & field,T value)79 inline void ObjectHeader::SetFieldPrimitive(const Field &field, T value)
80 {
81 ObjectAccessor::SetFieldPrimitive(this, field, value);
82 }
83
84 // NEED_READ_BARRIER = true , IS_DYN = false
85 template <bool NEED_READ_BARRIER, bool IS_DYN>
GetFieldObject(const Field & field)86 inline ObjectHeader *ObjectHeader::GetFieldObject(const Field &field) const
87 {
88 return ObjectAccessor::GetFieldObject<NEED_READ_BARRIER, IS_DYN>(this, field);
89 }
90
91 // NEED_WRITE_BARRIER = true , IS_DYN = false
92 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
SetFieldObject(const Field & field,ObjectHeader * value)93 inline void ObjectHeader::SetFieldObject(const Field &field, ObjectHeader *value)
94 {
95 ObjectAccessor::SetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, field, value);
96 }
97
98 // NEED_READ_BARRIER = true , IS_DYN = false
99 template <bool NEED_READ_BARRIER, bool IS_DYN>
GetFieldObject(const ManagedThread * thread,const Field & field)100 inline ObjectHeader *ObjectHeader::GetFieldObject(const ManagedThread *thread, const Field &field)
101 {
102 return ObjectAccessor::GetFieldObject<NEED_READ_BARRIER, IS_DYN>(thread, this, field);
103 }
104
105 // NEED_WRITE_BARRIER = true , IS_DYN = false
106 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
SetFieldObject(const ManagedThread * thread,const Field & field,ObjectHeader * value)107 inline void ObjectHeader::SetFieldObject(const ManagedThread *thread, const Field &field, ObjectHeader *value)
108 {
109 ObjectAccessor::SetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(thread, this, field, value);
110 }
111
112 // IS_VOLATILE = false , NEED_WRITE_BARRIER = true , IS_DYN = false
113 template <bool IS_VOLATILE, bool NEED_WRITE_BARRIER, bool IS_DYN>
SetFieldObject(const ManagedThread * thread,size_t offset,ObjectHeader * value)114 inline void ObjectHeader::SetFieldObject(const ManagedThread *thread, size_t offset, ObjectHeader *value)
115 {
116 ObjectAccessor::SetObject<IS_VOLATILE, NEED_WRITE_BARRIER, IS_DYN>(thread, this, offset, value);
117 }
118
119 template <class T>
GetFieldPrimitive(size_t offset,std::memory_order memoryOrder)120 inline T ObjectHeader::GetFieldPrimitive(size_t offset, std::memory_order memoryOrder) const
121 {
122 return ObjectAccessor::GetFieldPrimitive<T>(this, offset, memoryOrder);
123 }
124
125 template <class T>
SetFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)126 inline void ObjectHeader::SetFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
127 {
128 ObjectAccessor::SetFieldPrimitive(this, offset, value, memoryOrder);
129 }
130
131 // NEED_READ_BARRIER = true , IS_DYN = false
132 template <bool NEED_READ_BARRIER, bool IS_DYN>
GetFieldObject(size_t offset,std::memory_order memoryOrder)133 inline ObjectHeader *ObjectHeader::GetFieldObject(size_t offset, std::memory_order memoryOrder) const
134 {
135 return ObjectAccessor::GetFieldObject<NEED_READ_BARRIER, IS_DYN>(this, offset, memoryOrder);
136 }
137
138 // NEED_WRITE_BARRIER = true , IS_DYN = false
139 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
SetFieldObject(size_t offset,ObjectHeader * value,std::memory_order memoryOrder)140 inline void ObjectHeader::SetFieldObject(size_t offset, ObjectHeader *value, std::memory_order memoryOrder)
141 {
142 ObjectAccessor::SetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, offset, value, memoryOrder);
143 }
144
145 template <typename T>
CompareAndSetFieldPrimitive(size_t offset,T oldValue,T newValue,std::memory_order memoryOrder,bool strong)146 inline bool ObjectHeader::CompareAndSetFieldPrimitive(size_t offset, T oldValue, T newValue,
147 std::memory_order memoryOrder, bool strong)
148 {
149 return ObjectAccessor::CompareAndSetFieldPrimitive(this, offset, oldValue, newValue, memoryOrder, strong).first;
150 }
151
152 // NEED_WRITE_BARRIER = true , IS_DYN = false
153 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
CompareAndSetFieldObject(size_t offset,ObjectHeader * oldValue,ObjectHeader * newValue,std::memory_order memoryOrder,bool strong)154 inline bool ObjectHeader::CompareAndSetFieldObject(size_t offset, ObjectHeader *oldValue, ObjectHeader *newValue,
155 std::memory_order memoryOrder, bool strong)
156 {
157 return ObjectAccessor::CompareAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, offset, oldValue, newValue,
158 memoryOrder, strong)
159 .first;
160 }
161
162 template <typename T>
CompareAndExchangeFieldPrimitive(size_t offset,T oldValue,T newValue,std::memory_order memoryOrder,bool strong)163 inline T ObjectHeader::CompareAndExchangeFieldPrimitive(size_t offset, T oldValue, T newValue,
164 std::memory_order memoryOrder, bool strong)
165 {
166 return ObjectAccessor::CompareAndSetFieldPrimitive(this, offset, oldValue, newValue, memoryOrder, strong).second;
167 }
168
169 // NEED_WRITE_BARRIER = true , IS_DYN = false
170 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
CompareAndExchangeFieldObject(size_t offset,ObjectHeader * oldValue,ObjectHeader * newValue,std::memory_order memoryOrder,bool strong)171 inline ObjectHeader *ObjectHeader::CompareAndExchangeFieldObject(size_t offset, ObjectHeader *oldValue,
172 ObjectHeader *newValue, std::memory_order memoryOrder,
173 bool strong)
174 {
175 return ObjectAccessor::CompareAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, offset, oldValue, newValue,
176 memoryOrder, strong)
177 .second;
178 }
179
180 template <typename T>
GetAndSetFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)181 inline T ObjectHeader::GetAndSetFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
182 {
183 return ObjectAccessor::GetAndSetFieldPrimitive(this, offset, value, memoryOrder);
184 }
185
186 // NEED_WRITE_BARRIER = true , IS_DYN = false
187 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
GetAndSetFieldObject(size_t offset,ObjectHeader * value,std::memory_order memoryOrder)188 inline ObjectHeader *ObjectHeader::GetAndSetFieldObject(size_t offset, ObjectHeader *value,
189 std::memory_order memoryOrder)
190 {
191 return ObjectAccessor::GetAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, offset, value, memoryOrder);
192 }
193
194 template <typename T>
GetAndAddFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)195 inline T ObjectHeader::GetAndAddFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
196 {
197 return ObjectAccessor::GetAndAddFieldPrimitive(this, offset, value, memoryOrder);
198 }
199
200 template <typename T>
GetAndBitwiseOrFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)201 inline T ObjectHeader::GetAndBitwiseOrFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
202 {
203 return ObjectAccessor::GetAndBitwiseOrFieldPrimitive(this, offset, value, memoryOrder);
204 }
205
206 template <typename T>
GetAndBitwiseAndFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)207 inline T ObjectHeader::GetAndBitwiseAndFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
208 {
209 return ObjectAccessor::GetAndBitwiseAndFieldPrimitive(this, offset, value, memoryOrder);
210 }
211
212 template <typename T>
GetAndBitwiseXorFieldPrimitive(size_t offset,T value,std::memory_order memoryOrder)213 inline T ObjectHeader::GetAndBitwiseXorFieldPrimitive(size_t offset, T value, std::memory_order memoryOrder)
214 {
215 return ObjectAccessor::GetAndBitwiseXorFieldPrimitive(this, offset, value, memoryOrder);
216 }
217
218 } // namespace ark
219
220 #endif // PANDA_RUNTIME_OBJECT_HEADER_INL_H_
221