1 /**
2 * Copyright (c) 2021-2022 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 panda {
24
25 template <MTModeT MTMode>
GetHashCode()26 uint32_t ObjectHeader::GetHashCode()
27 {
28 // NOLINTNEXTLINE(readability-braces-around-statements)
29 if constexpr (MTMode == 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 /* = false */>
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 /* = false */>
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 template <bool is_volatile /* = false */, bool need_read_barrier /* = true */, bool is_dyn /* = false */>
GetFieldObject(int offset)55 inline ObjectHeader *ObjectHeader::GetFieldObject(int offset) const
56 {
57 return ObjectAccessor::GetObject<is_volatile, need_read_barrier, is_dyn>(this, offset);
58 }
59
60 template <bool is_volatile /* = false */, bool need_write_barrier /* = true */, bool is_dyn /* = false */>
SetFieldObject(size_t offset,ObjectHeader * value)61 inline void ObjectHeader::SetFieldObject(size_t offset, ObjectHeader *value)
62 {
63 ObjectAccessor::SetObject<is_volatile, need_write_barrier, is_dyn>(this, offset, value);
64 }
65
66 template <class T>
GetFieldPrimitive(const Field & field)67 inline T ObjectHeader::GetFieldPrimitive(const Field &field) const
68 {
69 return ObjectAccessor::GetFieldPrimitive<T>(this, field);
70 }
71
72 template <class T>
SetFieldPrimitive(const Field & field,T value)73 inline void ObjectHeader::SetFieldPrimitive(const Field &field, T value)
74 {
75 ObjectAccessor::SetFieldPrimitive(this, field, value);
76 }
77
78 template <bool need_read_barrier /* = true */, bool is_dyn /* = false */>
GetFieldObject(const Field & field)79 inline ObjectHeader *ObjectHeader::GetFieldObject(const Field &field) const
80 {
81 return ObjectAccessor::GetFieldObject<need_read_barrier, is_dyn>(this, field);
82 }
83
84 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
SetFieldObject(const Field & field,ObjectHeader * value)85 inline void ObjectHeader::SetFieldObject(const Field &field, ObjectHeader *value)
86 {
87 ObjectAccessor::SetFieldObject<need_write_barrier, is_dyn>(this, field, value);
88 }
89
90 template <bool need_read_barrier /* = true */, bool is_dyn /* = false */>
GetFieldObject(const ManagedThread * thread,const Field & field)91 inline ObjectHeader *ObjectHeader::GetFieldObject(const ManagedThread *thread, const Field &field)
92 {
93 return ObjectAccessor::GetFieldObject<need_read_barrier, is_dyn>(thread, this, field);
94 }
95
96 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
SetFieldObject(const ManagedThread * thread,const Field & field,ObjectHeader * value)97 inline void ObjectHeader::SetFieldObject(const ManagedThread *thread, const Field &field, ObjectHeader *value)
98 {
99 ObjectAccessor::SetFieldObject<need_write_barrier, is_dyn>(thread, this, field, value);
100 }
101
102 template <bool is_volatile /* = false */, bool need_write_barrier /* = true */, bool is_dyn /* = false */>
SetFieldObject(const ManagedThread * thread,size_t offset,ObjectHeader * value)103 inline void ObjectHeader::SetFieldObject(const ManagedThread *thread, size_t offset, ObjectHeader *value)
104 {
105 ObjectAccessor::SetObject<is_volatile, need_write_barrier, is_dyn>(thread, this, offset, value);
106 }
107
108 template <class T>
GetFieldPrimitive(size_t offset,std::memory_order memory_order)109 inline T ObjectHeader::GetFieldPrimitive(size_t offset, std::memory_order memory_order) const
110 {
111 return ObjectAccessor::GetFieldPrimitive<T>(this, offset, memory_order);
112 }
113
114 template <class T>
SetFieldPrimitive(size_t offset,T value,std::memory_order memory_order)115 inline void ObjectHeader::SetFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
116 {
117 ObjectAccessor::SetFieldPrimitive(this, offset, value, memory_order);
118 }
119
120 template <bool need_read_barrier /* = true */, bool is_dyn /* = false */>
GetFieldObject(size_t offset,std::memory_order memory_order)121 inline ObjectHeader *ObjectHeader::GetFieldObject(size_t offset, std::memory_order memory_order) const
122 {
123 return ObjectAccessor::GetFieldObject<need_read_barrier, is_dyn>(this, offset, memory_order);
124 }
125
126 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
SetFieldObject(size_t offset,ObjectHeader * value,std::memory_order memory_order)127 inline void ObjectHeader::SetFieldObject(size_t offset, ObjectHeader *value, std::memory_order memory_order)
128 {
129 ObjectAccessor::SetFieldObject<need_write_barrier, is_dyn>(this, offset, value, memory_order);
130 }
131
132 template <typename T>
CompareAndSetFieldPrimitive(size_t offset,T old_value,T new_value,std::memory_order memory_order,bool strong)133 inline bool ObjectHeader::CompareAndSetFieldPrimitive(size_t offset, T old_value, T new_value,
134 std::memory_order memory_order, bool strong)
135 {
136 return ObjectAccessor::CompareAndSetFieldPrimitive(this, offset, old_value, new_value, memory_order, strong).first;
137 }
138
139 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
CompareAndSetFieldObject(size_t offset,ObjectHeader * old_value,ObjectHeader * new_value,std::memory_order memory_order,bool strong)140 inline bool ObjectHeader::CompareAndSetFieldObject(size_t offset, ObjectHeader *old_value, ObjectHeader *new_value,
141 std::memory_order memory_order, bool strong)
142 {
143 return ObjectAccessor::CompareAndSetFieldObject<need_write_barrier, is_dyn>(this, offset, old_value, new_value,
144 memory_order, strong).first;
145 }
146
147 template <typename T>
CompareAndExchangeFieldPrimitive(size_t offset,T old_value,T new_value,std::memory_order memory_order,bool strong)148 inline T ObjectHeader::CompareAndExchangeFieldPrimitive(size_t offset, T old_value, T new_value,
149 std::memory_order memory_order, bool strong)
150 {
151 return ObjectAccessor::CompareAndSetFieldPrimitive(this, offset, old_value, new_value, memory_order, strong).second;
152 }
153
154 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
CompareAndExchangeFieldObject(size_t offset,ObjectHeader * old_value,ObjectHeader * new_value,std::memory_order memory_order,bool strong)155 inline ObjectHeader *ObjectHeader::CompareAndExchangeFieldObject(size_t offset, ObjectHeader *old_value,
156 ObjectHeader *new_value,
157 std::memory_order memory_order, bool strong)
158 {
159 return ObjectAccessor::CompareAndSetFieldObject<need_write_barrier, is_dyn>(this, offset, old_value, new_value,
160 memory_order, strong).second;
161 }
162
163 template <typename T>
GetAndSetFieldPrimitive(size_t offset,T value,std::memory_order memory_order)164 inline T ObjectHeader::GetAndSetFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
165 {
166 return ObjectAccessor::GetAndSetFieldPrimitive(this, offset, value, memory_order);
167 }
168
169 template <bool need_write_barrier /* = true */, bool is_dyn /* = false */>
GetAndSetFieldObject(size_t offset,ObjectHeader * value,std::memory_order memory_order)170 inline ObjectHeader *ObjectHeader::GetAndSetFieldObject(size_t offset, ObjectHeader *value,
171 std::memory_order memory_order)
172 {
173 return ObjectAccessor::GetAndSetFieldObject<need_write_barrier, is_dyn>(this, offset, value, memory_order);
174 }
175
176 template <typename T>
GetAndAddFieldPrimitive(size_t offset,T value,std::memory_order memory_order)177 inline T ObjectHeader::GetAndAddFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
178 {
179 return ObjectAccessor::GetAndAddFieldPrimitive(this, offset, value, memory_order);
180 }
181
182 template <typename T>
GetAndBitwiseOrFieldPrimitive(size_t offset,T value,std::memory_order memory_order)183 inline T ObjectHeader::GetAndBitwiseOrFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
184 {
185 return ObjectAccessor::GetAndBitwiseOrFieldPrimitive(this, offset, value, memory_order);
186 }
187
188 template <typename T>
GetAndBitwiseAndFieldPrimitive(size_t offset,T value,std::memory_order memory_order)189 inline T ObjectHeader::GetAndBitwiseAndFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
190 {
191 return ObjectAccessor::GetAndBitwiseAndFieldPrimitive(this, offset, value, memory_order);
192 }
193
194 template <typename T>
GetAndBitwiseXorFieldPrimitive(size_t offset,T value,std::memory_order memory_order)195 inline T ObjectHeader::GetAndBitwiseXorFieldPrimitive(size_t offset, T value, std::memory_order memory_order)
196 {
197 return ObjectAccessor::GetAndBitwiseXorFieldPrimitive(this, offset, value, memory_order);
198 }
199
200 } // namespace panda
201
202 #endif // PANDA_RUNTIME_OBJECT_HEADER_INL_H_
203