blob: f9f080ba31a766806f4df830cd3bbd0ca1f48d2c (
plain)
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
|
// Copyright 2018 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_MAYBE_OBJECT_H_
#define V8_OBJECTS_MAYBE_OBJECT_H_
#include "include/v8.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
class HeapObject;
class Smi;
// A MaybeObject is either a SMI, a strong reference to a HeapObject, a weak
// reference to a HeapObject, or a cleared weak reference. It's used for
// implementing in-place weak references (see design doc: goo.gl/j6SdcK )
class MaybeObject {
public:
bool IsSmi() const { return HAS_SMI_TAG(this); }
inline bool ToSmi(Smi** value);
bool IsClearedWeakHeapObject() {
return ::v8::internal::IsClearedWeakHeapObject(this);
}
inline bool IsStrongOrWeakHeapObject();
inline bool ToStrongOrWeakHeapObject(HeapObject** result);
inline bool ToStrongOrWeakHeapObject(HeapObject** result,
HeapObjectReferenceType* reference_type);
inline bool IsStrongHeapObject();
inline bool ToStrongHeapObject(HeapObject** result);
inline HeapObject* ToStrongHeapObject();
inline bool IsWeakHeapObject();
inline bool ToWeakHeapObject(HeapObject** result);
inline HeapObject* ToWeakHeapObject();
inline HeapObject* GetHeapObject();
static MaybeObject* FromSmi(Smi* smi) {
DCHECK(HAS_SMI_TAG(smi));
return reinterpret_cast<MaybeObject*>(smi);
}
static MaybeObject* FromObject(Object* object) {
DCHECK(!HasWeakHeapObjectTag(object));
return reinterpret_cast<MaybeObject*>(object);
}
static MaybeObject* MakeWeak(MaybeObject* object) {
DCHECK(object->IsStrongOrWeakHeapObject());
return AddWeakHeapObjectMask(object);
}
#ifdef VERIFY_HEAP
static void VerifyMaybeObjectPointer(MaybeObject* p);
#endif
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(MaybeObject);
};
// A HeapObjectReference is either a strong reference to a HeapObject, a weak
// reference to a HeapObject, or a cleared weak reference.
class HeapObjectReference : public MaybeObject {
public:
static HeapObjectReference* Strong(HeapObject* object) {
DCHECK(!HasWeakHeapObjectTag(object));
return reinterpret_cast<HeapObjectReference*>(object);
}
static HeapObjectReference* Weak(HeapObject* object) {
DCHECK(!HasWeakHeapObjectTag(object));
return AddWeakHeapObjectMask(object);
}
static HeapObjectReference* ClearedValue() {
return reinterpret_cast<HeapObjectReference*>(kClearedWeakHeapObject);
}
static void Update(HeapObjectReference** slot, HeapObject* value) {
DCHECK(!HAS_SMI_TAG(*slot));
DCHECK(Internals::HasHeapObjectTag(value));
#ifdef DEBUG
bool weak_before = HasWeakHeapObjectTag(*slot);
#endif
*slot = reinterpret_cast<HeapObjectReference*>(
reinterpret_cast<intptr_t>(value) |
(reinterpret_cast<intptr_t>(*slot) & kWeakHeapObjectMask));
#ifdef DEBUG
bool weak_after = HasWeakHeapObjectTag(*slot);
DCHECK_EQ(weak_before, weak_after);
#endif
}
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObjectReference);
};
} // namespace internal
} // namespace v8
#endif // V8_OBJECTS_MAYBE_OBJECT_H_
|
