1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_OBJECTS_VISITING_H_
#define V8_OBJECTS_VISITING_H_
#include "src/allocation.h"
#include "src/layout-descriptor.h"
#include "src/objects-body-descriptors.h"
#include "src/objects.h"
#include "src/objects/hash-table.h"
#include "src/objects/string.h"
#include "src/visitors.h"
namespace v8 {
namespace internal {
class BigInt;
class BytecodeArray;
class JSArrayBuffer;
class JSRegExp;
#define TYPED_VISITOR_ID_LIST(V) \
V(AllocationSite) \
V(BigInt) \
V(ByteArray) \
V(BytecodeArray) \
V(Cell) \
V(Code) \
V(CodeDataContainer) \
V(ConsString) \
V(FeedbackVector) \
V(FixedArray) \
V(FixedDoubleArray) \
V(FixedFloat64Array) \
V(FixedTypedArrayBase) \
V(JSArrayBuffer) \
V(JSFunction) \
V(JSObject) \
V(JSRegExp) \
V(JSWeakCollection) \
V(Map) \
V(Oddball) \
V(PropertyArray) \
V(PropertyCell) \
V(SeqOneByteString) \
V(SeqTwoByteString) \
V(SharedFunctionInfo) \
V(SlicedString) \
V(SmallOrderedHashMap) \
V(SmallOrderedHashSet) \
V(Symbol) \
V(ThinString) \
V(TransitionArray) \
V(WeakCell)
// The base class for visitors that need to dispatch on object type. The default
// behavior of all visit functions is to iterate body of the given object using
// the BodyDescriptor of the object.
//
// The visit functions return the size of the object cast to ResultType.
//
// This class is intended to be used in the following way:
//
// class SomeVisitor : public HeapVisitor<ResultType, SomeVisitor> {
// ...
// }
template <typename ResultType, typename ConcreteVisitor>
class HeapVisitor : public ObjectVisitor {
public:
V8_INLINE ResultType Visit(HeapObject* object);
V8_INLINE ResultType Visit(Map* map, HeapObject* object);
protected:
// A guard predicate for visiting the object.
// If it returns false then the default implementations of the Visit*
// functions bailout from iterating the object pointers.
V8_INLINE bool ShouldVisit(HeapObject* object) { return true; }
// Guard predicate for visiting the objects map pointer separately.
V8_INLINE bool ShouldVisitMapPointer() { return true; }
// A callback for visiting the map pointer in the object header.
V8_INLINE void VisitMapPointer(HeapObject* host, HeapObject** map);
#define VISIT(type) V8_INLINE ResultType Visit##type(Map* map, type* object);
TYPED_VISITOR_ID_LIST(VISIT)
#undef VISIT
V8_INLINE ResultType VisitShortcutCandidate(Map* map, ConsString* object);
V8_INLINE ResultType VisitNativeContext(Map* map, Context* object);
V8_INLINE ResultType VisitDataObject(Map* map, HeapObject* object);
V8_INLINE ResultType VisitJSObjectFast(Map* map, JSObject* object);
V8_INLINE ResultType VisitJSApiObject(Map* map, JSObject* object);
V8_INLINE ResultType VisitStruct(Map* map, HeapObject* object);
V8_INLINE ResultType VisitFreeSpace(Map* map, FreeSpace* object);
template <typename T>
static V8_INLINE T* Cast(HeapObject* object);
};
template <typename ConcreteVisitor>
class NewSpaceVisitor : public HeapVisitor<int, ConcreteVisitor> {
public:
V8_INLINE bool ShouldVisitMapPointer() { return false; }
// Special cases for young generation.
V8_INLINE int VisitJSFunction(Map* map, JSFunction* object);
V8_INLINE int VisitNativeContext(Map* map, Context* object);
V8_INLINE int VisitJSApiObject(Map* map, JSObject* object);
int VisitBytecodeArray(Map* map, BytecodeArray* object) {
UNREACHABLE();
return 0;
}
int VisitSharedFunctionInfo(Map* map, SharedFunctionInfo* object) {
UNREACHABLE();
return 0;
}
};
class WeakObjectRetainer;
// A weak list is single linked list where each element has a weak pointer to
// the next element. Given the head of the list, this function removes dead
// elements from the list and if requested records slots for next-element
// pointers. The template parameter T is a WeakListVisitor that defines how to
// access the next-element pointers.
template <class T>
Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
} // namespace internal
} // namespace v8
#endif // V8_OBJECTS_VISITING_H_
|
