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
16 #include "runtime/mem/gc/gc_root.h"
17
18 #include "libpandafile/panda_cache.h"
19 #include "runtime/include/object_header.h"
20 #include "runtime/include/runtime.h"
21 #include "runtime/include/stack_walker-inl.h"
22 #include "runtime/mem/refstorage/reference_storage.h"
23 #include "runtime/mem/gc/card_table-inl.h"
24 #include "runtime/mem/gc/gc.h"
25 #include "runtime/mem/gc/gc_root_type.h"
26 #include "runtime/mem/object_helpers.h"
27 #include "runtime/mem/refstorage/global_object_storage.h"
28 #include "runtime/include/panda_vm.h"
29
30 namespace panda::mem {
31
GCRoot(RootType type,ObjectHeader * obj)32 GCRoot::GCRoot(RootType type, ObjectHeader *obj)
33 {
34 type_ = type;
35 fromObject_ = nullptr;
36 object_ = obj;
37 }
38
GCRoot(RootType type,ObjectHeader * fromObject,ObjectHeader * obj)39 GCRoot::GCRoot(RootType type, ObjectHeader *fromObject, ObjectHeader *obj)
40 {
41 ASSERT((fromObject != nullptr && type == RootType::ROOT_TENURED) || type != RootType::ROOT_TENURED);
42 type_ = type;
43 fromObject_ = fromObject;
44 object_ = obj;
45 }
46
GetType() const47 RootType GCRoot::GetType() const
48 {
49 return type_;
50 }
51
GetObjectHeader() const52 ObjectHeader *GCRoot::GetObjectHeader() const
53 {
54 return object_;
55 }
56
GetFromObjectHeader() const57 ObjectHeader *GCRoot::GetFromObjectHeader() const
58 {
59 ASSERT((fromObject_ != nullptr && type_ == RootType::ROOT_TENURED) || type_ != RootType::ROOT_TENURED);
60 return fromObject_;
61 }
62
operator <<(std::ostream & os,const GCRoot & root)63 std::ostream &operator<<(std::ostream &os, const GCRoot &root)
64 {
65 switch (root.GetType()) {
66 case RootType::ROOT_CLASS:
67 os << "ROOT CLASS";
68 break;
69 case RootType::ROOT_FRAME:
70 os << "ROOT FRAME";
71 break;
72 case RootType::ROOT_THREAD:
73 os << "ROOT THREAD";
74 break;
75 case RootType::ROOT_TENURED:
76 os << "ROOT TENURED";
77 break;
78 case RootType::ROOT_NATIVE_GLOBAL:
79 os << "ROOT NATIVE_GLOBAL";
80 break;
81 case RootType::ROOT_NATIVE_LOCAL:
82 os << "ROOT NATIVE_LOCAL";
83 break;
84 case RootType::ROOT_AOT_STRING_SLOT:
85 os << "ROOT AOT_STRING_SLOT";
86 break;
87 case RootType::ROOT_UNKNOWN:
88 default:
89 LOG(FATAL, GC) << "ROOT UNKNOWN";
90 break;
91 }
92 os << std::hex << " " << root.GetObjectHeader() << std::endl;
93 return os;
94 }
95
96 template <class LanguageConfig>
VisitNonHeapRoots(const GCRootVisitor & gcRootVisitor,VisitGCRootFlags flags) const97 void RootManager<LanguageConfig>::VisitNonHeapRoots(const GCRootVisitor &gcRootVisitor, VisitGCRootFlags flags) const
98 {
99 VisitLocalRoots(gcRootVisitor);
100 VisitClassRoots(gcRootVisitor, flags);
101 VisitAotStringRoots(gcRootVisitor, flags);
102 VisitClassLinkerContextRoots(gcRootVisitor);
103 VisitVmRoots(gcRootVisitor);
104 auto *storage = vm_->GetGlobalObjectStorage();
105 if (storage != nullptr) {
106 storage->VisitObjects(gcRootVisitor, mem::RootType::ROOT_NATIVE_GLOBAL);
107 }
108 }
109
110 template <class LanguageConfig>
VisitCardTableRoots(CardTable * cardTable,ObjectAllocatorBase * allocator,GCRootVisitor rootVisitor,MemRangeChecker rangeChecker,ObjectChecker rangeObjectChecker,ObjectChecker fromObjectChecker,uint32_t processedFlag) const111 void RootManager<LanguageConfig>::VisitCardTableRoots(CardTable *cardTable, ObjectAllocatorBase *allocator,
112 GCRootVisitor rootVisitor, MemRangeChecker rangeChecker,
113 ObjectChecker rangeObjectChecker, ObjectChecker fromObjectChecker,
114 uint32_t processedFlag) const
115 {
116 cardTable->VisitMarked(
117 [&allocator, &rootVisitor, &rangeChecker, &rangeObjectChecker, &fromObjectChecker,
118 &cardTable](MemRange memRange) {
119 if (rangeChecker(memRange)) {
120 auto objectsInRangeVisitor = [&rootVisitor, &rangeObjectChecker,
121 &fromObjectChecker](ObjectHeader *objectHeader) {
122 auto traverseObjectInRange = [&rootVisitor, &rangeObjectChecker](ObjectHeader *fromObject,
123 ObjectHeader *objectToTraverse) {
124 if (rangeObjectChecker(objectToTraverse)) {
125 // The weak references from dynobjects should not be regarded as roots.
126 TaggedValue value(objectToTraverse);
127 if (!value.IsWeak()) {
128 rootVisitor(GCRoot(RootType::ROOT_TENURED, fromObject, objectToTraverse));
129 }
130 }
131 };
132 if (objectHeader->ClassAddr<BaseClass>() != nullptr && fromObjectChecker(objectHeader)) {
133 // The class may be null in the situation when a new object is allocated in the card
134 // we are visiting now, but the class is not set yet.
135 ObjectHelpers<LanguageConfig::LANG_TYPE>::TraverseAllObjects(objectHeader,
136 traverseObjectInRange);
137 }
138 };
139 allocator->IterateOverObjectsInRange(memRange, objectsInRangeVisitor);
140 } else {
141 cardTable->MarkCard(memRange.GetStartAddress());
142 }
143 },
144 processedFlag);
145 }
146
147 template <class LanguageConfig>
VisitRootsForThread(ManagedThread * thread,const GCRootVisitor & gcRootVisitor) const148 void RootManager<LanguageConfig>::VisitRootsForThread(ManagedThread *thread, const GCRootVisitor &gcRootVisitor) const
149 {
150 LOG(DEBUG, GC) << "Start collecting roots for thread " << thread->GetId();
151
152 thread->VisitGCRoots([&gcRootVisitor](ObjectHeader *obj) {
153 LOG(DEBUG, GC) << " Found root for thread" << GetDebugInfoAboutObject(obj);
154 gcRootVisitor({RootType::ROOT_THREAD, obj});
155 });
156 LOG(DEBUG, GC) << "Finish collecting roots for thread " << thread->GetId();
157 }
158
159 template <class LanguageConfig>
VisitLocalRoots(const GCRootVisitor & gcRootVisitor) const160 void RootManager<LanguageConfig>::VisitLocalRoots(const GCRootVisitor &gcRootVisitor) const
161 {
162 auto threadVisitor = [this, &gcRootVisitor](ManagedThread *thread) {
163 VisitRootsForThread(thread, gcRootVisitor);
164 for (auto stack = StackWalker::Create(thread); stack.HasFrame(); stack.NextFrame()) {
165 LOG(DEBUG, GC) << " VisitRoots frame " << std::hex << stack.GetFp();
166 stack.IterateObjects([this, &gcRootVisitor](auto &vreg) {
167 this->VisitRegisterRoot(vreg, gcRootVisitor);
168 return true;
169 });
170 }
171 return true;
172 };
173 vm_->GetThreadManager()->EnumerateThreads(threadVisitor);
174 }
175
176 template <class LanguageConfig>
177 template <class VRegRef>
VisitRegisterRoot(const VRegRef & vRegister,const GCRootVisitor & gcRootVisitor) const178 void RootManager<LanguageConfig>::VisitRegisterRoot(const VRegRef &vRegister, const GCRootVisitor &gcRootVisitor) const
179 {
180 if (UNLIKELY(vRegister.HasObject())) {
181 ObjectHeader *objectHeader = vRegister.GetReference();
182 if (objectHeader != nullptr) {
183 LOG(DEBUG, GC) << " Found root for register" << GetDebugInfoAboutObject(objectHeader);
184 gcRootVisitor({RootType::ROOT_FRAME, objectHeader});
185 }
186 }
187 }
188
189 template <class LanguageConfig>
VisitVmRoots(const GCRootVisitor & gcRootVisitor) const190 void RootManager<LanguageConfig>::VisitVmRoots(const GCRootVisitor &gcRootVisitor) const
191 {
192 vm_->VisitVmRoots(gcRootVisitor);
193 }
194
195 template <class LanguageConfig>
VisitAotStringRoots(const GCRootVisitor & gcRootVisitor,VisitGCRootFlags flags) const196 void RootManager<LanguageConfig>::VisitAotStringRoots(const GCRootVisitor &gcRootVisitor, VisitGCRootFlags flags) const
197 {
198 trace::ScopedTrace scopedTrace(__FUNCTION__);
199 LOG(DEBUG, GC) << "Start collecting AOT string slot roots";
200 Runtime::GetCurrent()->GetClassLinker()->GetAotManager()->VisitAotStringRoots(
201 [&gcRootVisitor](ObjectHeader **slot) {
202 gcRootVisitor({RootType::ROOT_AOT_STRING_SLOT, *slot});
203 },
204 (flags & VisitGCRootFlags::ACCESS_ROOT_AOT_STRINGS_ONLY_YOUNG) != 0);
205 LOG(DEBUG, GC) << "Finish collecting AOT string slot roots";
206 }
207
208 template <class LanguageConfig>
UpdateAotStringRoots()209 void RootManager<LanguageConfig>::UpdateAotStringRoots()
210 {
211 trace::ScopedTrace scopedTrace(__FUNCTION__);
212 LOG(DEBUG, GC) << "=== AOT string slot roots update. BEGIN ===";
213 auto hm = vm_->GetHeapManager();
214 Runtime::GetCurrent()->GetClassLinker()->GetAotManager()->UpdateAotStringRoots(
215 [](ObjectHeader **root) {
216 auto rootValue = *root;
217 if (rootValue->IsForwarded()) {
218 *root = ::panda::mem::GetForwardAddress(rootValue);
219 }
220 },
221 [&hm](const ObjectHeader *root) { return hm->IsObjectInYoungSpace(root); });
222 LOG(DEBUG, GC) << "=== AOT string slot roots update. END ===";
223 }
224
225 template <class LanguageConfig>
UpdateVmRefs()226 void RootManager<LanguageConfig>::UpdateVmRefs()
227 {
228 vm_->UpdateVmRefs();
229 }
230
231 template <class LanguageConfig>
UpdateGlobalObjectStorage()232 void RootManager<LanguageConfig>::UpdateGlobalObjectStorage()
233 {
234 auto globalStorage = vm_->GetGlobalObjectStorage();
235 if (globalStorage != nullptr) {
236 globalStorage->UpdateMovedRefs();
237 }
238 }
239
240 template <class LanguageConfig>
VisitClassRoots(const GCRootVisitor & gcRootVisitor,VisitGCRootFlags flags) const241 void RootManager<LanguageConfig>::VisitClassRoots(const GCRootVisitor &gcRootVisitor, VisitGCRootFlags flags) const
242 {
243 LOG(DEBUG, GC) << "Start collecting roots for classes";
244 auto classLinker = Runtime::GetCurrent()->GetClassLinker();
245 auto classRootVisitor = [&gcRootVisitor](Class *cls) {
246 gcRootVisitor({RootType::ROOT_CLASS, cls->GetManagedObject()});
247 LOG(DEBUG, GC) << " Found class root " << GetDebugInfoAboutObject(cls->GetManagedObject());
248 return true;
249 };
250 auto *extension = classLinker->GetExtension(LanguageConfig::LANG);
251 extension->EnumerateClasses(classRootVisitor, flags);
252
253 LOG(DEBUG, GC) << "Finish collecting roots for classes";
254 }
255
256 template <class LanguageConfig>
UpdateThreadLocals()257 void RootManager<LanguageConfig>::UpdateThreadLocals()
258 {
259 LOG(DEBUG, GC) << "=== ThreadLocals Update moved. BEGIN ===";
260 vm_->GetThreadManager()->EnumerateThreads([](ManagedThread *thread) {
261 thread->UpdateGCRoots();
262 return true;
263 });
264 LOG(DEBUG, GC) << "=== ThreadLocals Update moved. END ===";
265 }
266
267 template <class LanguageConfig>
VisitClassLinkerContextRoots(const GCRootVisitor & gcRootVisitor) const268 void RootManager<LanguageConfig>::VisitClassLinkerContextRoots(const GCRootVisitor &gcRootVisitor) const
269 {
270 LOG(DEBUG, GC) << "Start collecting roots for class linker contexts";
271 auto classLinker = Runtime::GetCurrent()->GetClassLinker();
272 auto *extension = classLinker->GetExtension(LanguageConfig::LANG);
273 extension->EnumerateContexts([&gcRootVisitor](ClassLinkerContext *ctx) {
274 ctx->VisitGCRoots([&gcRootVisitor](ObjectHeader *obj) {
275 LOG(DEBUG, GC) << " Found root for class linker context " << GetDebugInfoAboutObject(obj);
276 gcRootVisitor({RootType::ROOT_CLASS_LINKER, obj});
277 });
278 return true;
279 });
280 LOG(DEBUG, GC) << "Finish collecting roots for class linker contexts";
281 }
282
283 template <class LanguageConfig>
UpdateClassLinkerContextRoots()284 void RootManager<LanguageConfig>::UpdateClassLinkerContextRoots()
285 {
286 auto classLinker = Runtime::GetCurrent()->GetClassLinker();
287 auto *extension = classLinker->GetExtension(LanguageConfig::LANG);
288 extension->EnumerateContexts([](ClassLinkerContext *ctx) {
289 ctx->UpdateGCRoots();
290 return true;
291 });
292 }
293
operator &(VisitGCRootFlags left,VisitGCRootFlags right)294 uint32_t operator&(VisitGCRootFlags left, VisitGCRootFlags right)
295 {
296 return static_cast<uint32_t>(left) & static_cast<uint32_t>(right);
297 }
298
operator |(VisitGCRootFlags left,VisitGCRootFlags right)299 VisitGCRootFlags operator|(VisitGCRootFlags left, VisitGCRootFlags right)
300 {
301 return static_cast<VisitGCRootFlags>(static_cast<uint32_t>(left) | static_cast<uint32_t>(right));
302 }
303
304 TEMPLATE_CLASS_LANGUAGE_CONFIG(RootManager);
305
306 } // namespace panda::mem
307