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_CORETYPES_ARRAY_INL_H_
16 #define PANDA_RUNTIME_CORETYPES_ARRAY_INL_H_
17
18 #include <type_traits>
19
20 #include "runtime/include/coretypes/array.h"
21 #include "runtime/include/exceptions.h"
22 #include "runtime/include/object_accessor-inl.h"
23 #include "runtime/handle_scope.h"
24 #include "runtime/mem/vm_handle.h"
25
26 namespace ark::coretypes {
27
28 // IS_VOLATILE = false
29 template <class T, bool IS_VOLATILE>
GetPrimitive(size_t offset)30 inline T Array::GetPrimitive(size_t offset) const
31 {
32 return ObjectAccessor::GetPrimitive<T, IS_VOLATILE>(this, GetDataOffset() + offset);
33 }
34
35 // IS_VOLATILE = false
36 template <class T, bool IS_VOLATILE>
SetPrimitive(size_t offset,T value)37 inline void Array::SetPrimitive(size_t offset, T value)
38 {
39 ObjectAccessor::SetPrimitive<T, IS_VOLATILE>(this, GetDataOffset() + offset, value);
40 }
41
42 // IS_VOLATILE = false , NEED_READ_BARRIER = true , bool IS_DYN = false
43 template <bool IS_VOLATILE, bool NEED_READ_BARRIER, bool IS_DYN>
GetObject(int offset)44 inline ObjectHeader *Array::GetObject(int offset) const
45 {
46 return ObjectAccessor::GetObject<IS_VOLATILE, NEED_READ_BARRIER, IS_DYN>(this, GetDataOffset() + offset);
47 }
48
49 // IS_VOLATILE = false , NEED_READ_BARRIER = true , bool IS_DYN = false
50 template <bool IS_VOLATILE, bool NEED_WRITE_BARRIER, bool IS_DYN>
SetObject(size_t offset,ObjectHeader * value)51 inline void Array::SetObject(size_t offset, ObjectHeader *value)
52 {
53 ObjectAccessor::SetObject<IS_VOLATILE, NEED_WRITE_BARRIER, IS_DYN>(this, GetDataOffset() + offset, value);
54 }
55
56 template <class T>
GetPrimitive(size_t offset,std::memory_order memoryOrder)57 inline T Array::GetPrimitive(size_t offset, std::memory_order memoryOrder) const
58 {
59 return ObjectAccessor::GetFieldPrimitive<T>(this, GetDataOffset() + offset, memoryOrder);
60 }
61
62 template <class T>
SetPrimitive(size_t offset,T value,std::memory_order memoryOrder)63 inline void Array::SetPrimitive(size_t offset, T value, std::memory_order memoryOrder)
64 {
65 ObjectAccessor::SetFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
66 }
67
68 // NEED_READ_BARRIER = true , IS_DYN = false
69 template <bool NEED_READ_BARRIER, bool IS_DYN>
GetObject(size_t offset,std::memory_order memoryOrder)70 inline ObjectHeader *Array::GetObject(size_t offset, std::memory_order memoryOrder) const
71 {
72 return ObjectAccessor::GetFieldObject<NEED_READ_BARRIER, IS_DYN>(this, GetDataOffset() + offset, memoryOrder);
73 }
74
75 // NEED_WRITE_BARRIER = true , IS_DYN = false
76 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
SetObject(size_t offset,ObjectHeader * value,std::memory_order memoryOrder)77 inline void Array::SetObject(size_t offset, ObjectHeader *value, std::memory_order memoryOrder)
78 {
79 ObjectAccessor::SetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, GetDataOffset() + offset, value, memoryOrder);
80 }
81
82 template <typename T>
CompareAndSetPrimitive(size_t offset,T oldValue,T newValue,std::memory_order memoryOrder,bool strong)83 inline bool Array::CompareAndSetPrimitive(size_t offset, T oldValue, T newValue, std::memory_order memoryOrder,
84 bool strong)
85 {
86 return ObjectAccessor::CompareAndSetFieldPrimitive(this, GetDataOffset() + offset, oldValue, newValue, memoryOrder,
87 strong)
88 .first;
89 }
90
91 // NEED_WRITE_BARRIER = true , IS_DYN = false
92 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
CompareAndSetObject(size_t offset,ObjectHeader * oldValue,ObjectHeader * newValue,std::memory_order memoryOrder,bool strong)93 inline bool Array::CompareAndSetObject(size_t offset, ObjectHeader *oldValue, ObjectHeader *newValue,
94 std::memory_order memoryOrder, bool strong)
95 {
96 auto fieldOffset = GetDataOffset() + offset;
97 return ObjectAccessor::CompareAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, fieldOffset, oldValue, newValue,
98 memoryOrder, strong)
99 .first;
100 }
101
102 template <typename T>
CompareAndExchangePrimitive(size_t offset,T oldValue,T newValue,std::memory_order memoryOrder,bool strong)103 inline T Array::CompareAndExchangePrimitive(size_t offset, T oldValue, T newValue, std::memory_order memoryOrder,
104 bool strong)
105 {
106 return ObjectAccessor::CompareAndSetFieldPrimitive(this, GetDataOffset() + offset, oldValue, newValue, memoryOrder,
107 strong)
108 .second;
109 }
110
111 // NEED_READ_BARRIER = true , IS_DYN = false
112 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
CompareAndExchangeObject(size_t offset,ObjectHeader * oldValue,ObjectHeader * newValue,std::memory_order memoryOrder,bool strong)113 inline ObjectHeader *Array::CompareAndExchangeObject(size_t offset, ObjectHeader *oldValue, ObjectHeader *newValue,
114 std::memory_order memoryOrder, bool strong)
115 {
116 auto fieldOffset = GetDataOffset() + offset;
117 return ObjectAccessor::CompareAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, fieldOffset, oldValue, newValue,
118 memoryOrder, strong)
119 .second;
120 }
121
122 template <typename T>
GetAndSetPrimitive(size_t offset,T value,std::memory_order memoryOrder)123 inline T Array::GetAndSetPrimitive(size_t offset, T value, std::memory_order memoryOrder)
124 {
125 return ObjectAccessor::GetAndSetFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
126 }
127
128 // NEED_READ_BARRIER = true , IS_DYN = false
129 template <bool NEED_WRITE_BARRIER, bool IS_DYN>
GetAndSetObject(size_t offset,ObjectHeader * value,std::memory_order memoryOrder)130 inline ObjectHeader *Array::GetAndSetObject(size_t offset, ObjectHeader *value, std::memory_order memoryOrder)
131 {
132 return ObjectAccessor::GetAndSetFieldObject<NEED_WRITE_BARRIER, IS_DYN>(this, GetDataOffset() + offset, value,
133 memoryOrder);
134 }
135
136 template <typename T>
GetAndAddPrimitive(size_t offset,T value,std::memory_order memoryOrder)137 inline T Array::GetAndAddPrimitive(size_t offset, T value, std::memory_order memoryOrder)
138 {
139 return ObjectAccessor::GetAndAddFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
140 }
141
142 template <typename T>
GetAndBitwiseOrPrimitive(size_t offset,T value,std::memory_order memoryOrder)143 inline T Array::GetAndBitwiseOrPrimitive(size_t offset, T value, std::memory_order memoryOrder)
144 {
145 return ObjectAccessor::GetAndBitwiseOrFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
146 }
147
148 template <typename T>
GetAndBitwiseAndPrimitive(size_t offset,T value,std::memory_order memoryOrder)149 inline T Array::GetAndBitwiseAndPrimitive(size_t offset, T value, std::memory_order memoryOrder)
150 {
151 return ObjectAccessor::GetAndBitwiseAndFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
152 }
153
154 template <typename T>
GetAndBitwiseXorPrimitive(size_t offset,T value,std::memory_order memoryOrder)155 inline T Array::GetAndBitwiseXorPrimitive(size_t offset, T value, std::memory_order memoryOrder)
156 {
157 return ObjectAccessor::GetAndBitwiseXorFieldPrimitive(this, GetDataOffset() + offset, value, memoryOrder);
158 }
159
160 template <class T, bool NEED_WRITE_BARRIER, bool IS_DYN>
Set(ArraySizeT idx,T elem)161 inline void Array::Set(ArraySizeT idx, T elem)
162 {
163 constexpr bool IS_REF = std::is_pointer_v<T> && std::is_base_of_v<ObjectHeader, std::remove_pointer_t<T>>;
164
165 static_assert(std::is_arithmetic_v<T> || IS_REF, "T should be arithmetic type or pointer to managed object type");
166
167 size_t elemSize = (IS_REF && !IS_DYN) ? sizeof(ObjectPointerType) : sizeof(T);
168 size_t offset = elemSize * idx;
169
170 // Disable checks due to clang-tidy bug https://bugs.llvm.org/show_bug.cgi?id=32203
171 // NOLINTNEXTLINE(readability-braces-around-statements)
172 if constexpr (IS_REF) {
173 ObjectAccessor::SetObject<false, NEED_WRITE_BARRIER, IS_DYN>(this, GetDataOffset() + offset, elem);
174 // NOLINTNEXTLINE(readability-misleading-indentation)
175 } else {
176 ObjectAccessor::SetPrimitive(this, GetDataOffset() + offset, elem);
177 }
178 }
179
180 // NEED_READ_BARRIER = true , IS_DYN = false
181 template <class T, bool NEED_READ_BARRIER, bool IS_DYN>
Get(ArraySizeT idx)182 inline T Array::Get(ArraySizeT idx) const
183 {
184 constexpr bool IS_REF = std::is_pointer_v<T> && std::is_base_of_v<ObjectHeader, std::remove_pointer_t<T>>;
185
186 static_assert(std::is_arithmetic_v<T> || IS_REF, "T should be arithmetic type or pointer to managed object type");
187
188 size_t offset = GetElementSize<T, IS_DYN>() * idx;
189
190 if constexpr (IS_REF) {
191 return ObjectAccessor::GetObject<false, NEED_READ_BARRIER, IS_DYN>(this, GetDataOffset() + offset);
192 }
193
194 return ObjectAccessor::GetPrimitive<T>(this, GetDataOffset() + offset);
195 }
196
197 template <class T, bool IS_DYN>
GetElementSize()198 inline constexpr size_t Array::GetElementSize()
199 {
200 constexpr bool IS_REF = std::is_pointer_v<T> && std::is_base_of_v<ObjectHeader, std::remove_pointer_t<T>>;
201 static_assert(std::is_arithmetic_v<T> || IS_REF, "T should be arithmetic type or pointer to managed object type");
202 return (IS_REF && !IS_DYN) ? sizeof(ObjectPointerType) : sizeof(T);
203 }
204
205 template <class T>
GetBase()206 T Array::GetBase()
207 {
208 return reinterpret_cast<T>(ToUintPtr(this) + GetDataOffset());
209 }
210
211 // NEED_WRITE_BARRIER = true , IS_DYN = false
212 template <class T, bool NEED_WRITE_BARRIER, bool IS_DYN>
Set(const ManagedThread * thread,ArraySizeT idx,T elem)213 inline void Array::Set([[maybe_unused]] const ManagedThread *thread, ArraySizeT idx, T elem)
214 {
215 constexpr bool IS_REF = std::is_pointer_v<T> && std::is_base_of_v<ObjectHeader, std::remove_pointer_t<T>>;
216
217 static_assert(std::is_arithmetic_v<T> || IS_REF, "T should be arithmetic type or pointer to managed object type");
218
219 size_t elemSize = (IS_REF && !IS_DYN) ? sizeof(ObjectPointerType) : sizeof(T);
220 size_t offset = elemSize * idx;
221
222 // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon)
223 if constexpr (IS_REF) {
224 ObjectAccessor::SetObject<false, NEED_WRITE_BARRIER, IS_DYN>(thread, this, GetDataOffset() + offset, elem);
225 } else { // NOLINTNEXTLINE(readability-misleading-indentation)
226 ObjectAccessor::SetPrimitive(this, GetDataOffset() + offset, elem);
227 }
228 }
229
230 // NEED_READ_BARRIER = true , IS_DYN = false
231 template <class T, bool NEED_READ_BARRIER, bool IS_DYN>
Get(const ManagedThread * thread,ArraySizeT idx)232 inline T Array::Get([[maybe_unused]] const ManagedThread *thread, ArraySizeT idx) const
233 {
234 constexpr bool IS_REF = std::is_pointer_v<T> && std::is_base_of_v<ObjectHeader, std::remove_pointer_t<T>>;
235
236 static_assert(std::is_arithmetic_v<T> || IS_REF, "T should be arithmetic type or pointer to managed object type");
237
238 size_t elemSize = (IS_REF && !IS_DYN) ? sizeof(ObjectPointerType) : sizeof(T);
239 size_t offset = elemSize * idx;
240
241 // NOLINTNEXTLINE(readability-braces-around-statements, bugprone-suspicious-semicolon)
242 if constexpr (IS_REF) {
243 return ObjectAccessor::GetObject<false, NEED_READ_BARRIER, IS_DYN>(thread, this, GetDataOffset() + offset);
244 }
245 return ObjectAccessor::GetPrimitive<T>(this, GetDataOffset() + offset);
246 }
247
248 /* static */
249 template <class DimIterator>
CreateMultiDimensionalArray(ManagedThread * thread,ark::Class * klass,uint32_t nargs,const DimIterator & iter,size_t dimIdx)250 Array *Array::CreateMultiDimensionalArray(ManagedThread *thread, ark::Class *klass, uint32_t nargs,
251 const DimIterator &iter, size_t dimIdx)
252 {
253 auto arrSize = iter.Get(dimIdx);
254 if (arrSize < 0) {
255 ark::ThrowNegativeArraySizeException(arrSize);
256 return nullptr;
257 }
258 [[maybe_unused]] HandleScope<ObjectHeader *> scope(thread);
259 // Will be added later special rule for CheckObjHeaderTypeRef and VMHandler.
260 // SUPPRESS_CSA_NEXTLINE(alpha.core.CheckObjHeaderTypeRef)
261 VMHandle<Array> handle(thread, Array::Create(klass, arrSize));
262
263 // avoid recursive OOM.
264 if (handle.GetPtr() == nullptr) {
265 return nullptr;
266 }
267 auto *component = klass->GetComponentType();
268
269 if (component->IsArrayClass() && dimIdx + 1 < nargs) {
270 for (int32_t idx = 0; idx < arrSize; idx++) {
271 auto *array = CreateMultiDimensionalArray(thread, component, nargs, iter, dimIdx + 1);
272
273 if (array == nullptr) {
274 return nullptr;
275 }
276
277 handle.GetPtr()->template Set<Array *>(idx, array);
278 }
279 }
280
281 return handle.GetPtr();
282 }
283 } // namespace ark::coretypes
284
285 #endif // PANDA_RUNTIME_CORETYPES_ARRAY_INL_H_
286