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
16 #ifndef PANDA_RUNTIME_MEM_GC_DYNAMIC_GC_MARKER_DYNAMIC_INL_H
17 #define PANDA_RUNTIME_MEM_GC_DYNAMIC_GC_MARKER_DYNAMIC_INL_H
18
19 #include "runtime/mem/gc/gc_marker.h"
20 #include "runtime/include/coretypes/dyn_objects.h"
21
22 namespace ark::mem {
23 template <typename Marker>
HandleObject(GCMarkingStackType * objectsStack,const ObjectHeader * object,const BaseClass * baseCls)24 void GCMarker<Marker, LANG_TYPE_DYNAMIC>::HandleObject(GCMarkingStackType *objectsStack, const ObjectHeader *object,
25 const BaseClass *baseCls)
26 {
27 ASSERT(baseCls->IsDynamicClass());
28 auto *cls = static_cast<const HClass *>(baseCls);
29 // Handle dyn_class
30 ObjectHeader *dynClass = cls->GetManagedObject();
31 if (AsMarker()->MarkIfNotMarked(dynClass)) {
32 objectsStack->PushToStack(object, dynClass);
33 }
34 // mark object data
35 uint32_t objBodySize = cls->GetObjectSize() - ObjectHeader::ObjectHeaderSize();
36 ASSERT(objBodySize % TaggedValue::TaggedTypeSize() == 0);
37 uint32_t numOfFields = objBodySize / TaggedValue::TaggedTypeSize();
38 size_t startAddr = reinterpret_cast<uintptr_t>(object) + ObjectHeader::ObjectHeaderSize();
39 for (uint32_t i = 0; i < numOfFields; i++) {
40 uint32_t fieldOffset = i * TaggedValue::TaggedTypeSize();
41 if (cls->IsNativeField(ObjectHeader::ObjectHeaderSize() + fieldOffset)) {
42 continue;
43 }
44 auto *fieldAddr = reinterpret_cast<std::atomic<TaggedType> *>(startAddr + fieldOffset);
45 // Atomic with relaxed order reason: to correct read the value
46 TaggedValue taggedValue(fieldAddr->load(std::memory_order_relaxed));
47 if (!taggedValue.IsHeapObject()) {
48 continue;
49 }
50
51 ObjectHeader *objectHeader = taggedValue.GetHeapObject();
52 if (AsMarker()->MarkIfNotMarked(objectHeader)) {
53 objectsStack->PushToStack(object, objectHeader);
54 }
55 }
56 }
57
58 template <typename Marker>
HandleClass(GCMarkingStackType * objectsStack,const coretypes::DynClass * cls)59 void GCMarker<Marker, LANG_TYPE_DYNAMIC>::HandleClass(GCMarkingStackType *objectsStack, const coretypes::DynClass *cls)
60 {
61 // mark Hclass Data & Prototype
62 HClass *klass = const_cast<coretypes::DynClass *>(cls)->GetHClass();
63 // klass_size is sizeof DynClass include JSHClass, which is saved in root DynClass.
64 size_t klassSize = cls->ClassAddr<HClass>()->GetObjectSize();
65
66 uintptr_t startAddr = reinterpret_cast<uintptr_t>(klass) + sizeof(HClass);
67 size_t bodySize = klassSize - sizeof(coretypes::DynClass) - sizeof(HClass);
68 size_t numOfFields = bodySize / TaggedValue::TaggedTypeSize();
69 for (size_t i = 0; i < numOfFields; i++) {
70 auto *addr = reinterpret_cast<std::atomic<TaggedType> *>(startAddr + i * TaggedValue::TaggedTypeSize());
71 // Atomic with relaxed order reason: to correct read the value
72 coretypes::TaggedValue taggedValue(addr->load(std::memory_order_relaxed));
73 if (!taggedValue.IsHeapObject()) {
74 continue;
75 }
76 ObjectHeader *objectHeader = taggedValue.GetHeapObject();
77 if (AsMarker()->MarkIfNotMarked(objectHeader)) {
78 objectsStack->PushToStack(cls, objectHeader);
79 }
80 }
81 }
82
83 template <typename Marker>
HandleArrayClass(GCMarkingStackType * objectsStack,const coretypes::Array * arrayObject,const BaseClass * cls)84 void GCMarker<Marker, LANG_TYPE_DYNAMIC>::HandleArrayClass(GCMarkingStackType *objectsStack,
85 const coretypes::Array *arrayObject,
86 [[maybe_unused]] const BaseClass *cls)
87 {
88 LOG(DEBUG, GC) << "Dyn Array object: " << GetDebugInfoAboutObject(arrayObject);
89 ArraySizeT arrayLength = arrayObject->GetLength();
90 ASSERT(cls->IsDynamicClass());
91 for (coretypes::ArraySizeT i = 0; i < arrayLength; i++) {
92 TaggedValue arrayElement(arrayObject->Get<TaggedType, true, true>(i));
93 if (!arrayElement.IsHeapObject()) {
94 continue;
95 }
96 ObjectHeader *elementObject = arrayElement.GetHeapObject();
97 if (AsMarker()->MarkIfNotMarked(elementObject)) {
98 objectsStack->PushToStack(arrayObject, elementObject);
99 }
100 }
101 }
102
103 template <typename Marker>
MarkInstance(GCMarkingStackType * objectsStack,const ObjectHeader * object,const BaseClass * baseCls,const ReferenceCheckPredicateT & refPred)104 void GCMarker<Marker, LANG_TYPE_DYNAMIC>::MarkInstance(GCMarkingStackType *objectsStack, const ObjectHeader *object,
105 const BaseClass *baseCls,
106 const ReferenceCheckPredicateT &refPred)
107 {
108 ASSERT(baseCls->IsDynamicClass());
109 if (GetGC()->IsReference(nullptr, object, refPred)) {
110 GetGC()->ProcessReference(objectsStack, nullptr, object, GC::EmptyReferenceProcessPredicate);
111 return;
112 }
113 MarkInstance(objectsStack, object, baseCls);
114 }
115
116 template <typename Marker>
MarkInstance(GCMarkingStackType * objectsStack,const ObjectHeader * object,const BaseClass * baseCls)117 void GCMarker<Marker, LANG_TYPE_DYNAMIC>::MarkInstance(GCMarkingStackType *objectsStack, const ObjectHeader *object,
118 const BaseClass *baseCls)
119 {
120 ASSERT(baseCls->IsDynamicClass());
121 auto *cls = static_cast<const HClass *>(baseCls);
122 // push to stack after marked, so just return here.
123 if (cls->IsNativePointer() || cls->IsString()) {
124 return;
125 }
126 if (cls->IsHClass()) {
127 auto dynClass = static_cast<const ark::coretypes::DynClass *>(object);
128 HandleClass(objectsStack, dynClass);
129 } else if (cls->IsArray()) {
130 auto *arrayObject = static_cast<const ark::coretypes::Array *>(object);
131 HandleArrayClass(objectsStack, arrayObject, cls);
132 } else {
133 HandleObject(objectsStack, object, cls);
134 }
135 }
136 } // namespace ark::mem
137
138 #endif // PANDA_RUNTIME_MEM_GC_DYNAMIC_GC_MARKER_DYNAMIC_INL_H
139