Line data Source code
1 : // Copyright 2018 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_OBJECTS_MAYBE_OBJECT_INL_H_
6 : #define V8_OBJECTS_MAYBE_OBJECT_INL_H_
7 :
8 : #include "src/objects/maybe-object.h"
9 :
10 : #ifdef V8_COMPRESS_POINTERS
11 : #include "src/isolate.h"
12 : #endif
13 : #include "src/objects-inl.h"
14 : #include "src/objects/slots-inl.h"
15 :
16 : namespace v8 {
17 : namespace internal {
18 :
19 1685387 : bool MaybeObject::ToSmi(Smi* value) {
20 1685387 : if (HAS_SMI_TAG(ptr_)) {
21 1498118 : *value = Smi::cast(Object(ptr_));
22 1498118 : return true;
23 : }
24 : return false;
25 : }
26 :
27 3744308956 : Smi MaybeObject::ToSmi() const {
28 : DCHECK(HAS_SMI_TAG(ptr_));
29 7488620959 : return Smi::cast(Object(ptr_));
30 : }
31 :
32 : bool MaybeObject::IsStrongOrWeak() const {
33 273776914 : if (IsSmi() || IsCleared()) {
34 : return false;
35 : }
36 : return true;
37 : }
38 :
39 3131541760 : bool MaybeObject::GetHeapObject(HeapObject* result) const {
40 4056114317 : if (IsSmi() || IsCleared()) {
41 : return false;
42 : }
43 914113472 : *result = GetHeapObject();
44 914946490 : return true;
45 : }
46 :
47 7033699 : bool MaybeObject::GetHeapObject(HeapObject* result,
48 : HeapObjectReferenceType* reference_type) const {
49 13505709 : if (IsSmi() || IsCleared()) {
50 : return false;
51 : }
52 : *reference_type = HasWeakHeapObjectTag(ptr_)
53 : ? HeapObjectReferenceType::WEAK
54 6471770 : : HeapObjectReferenceType::STRONG;
55 6471770 : *result = GetHeapObject();
56 6471770 : return true;
57 : }
58 :
59 : bool MaybeObject::IsStrong() const {
60 476882 : return !HasWeakHeapObjectTag(ptr_) && !IsSmi();
61 : }
62 :
63 838616839 : bool MaybeObject::GetHeapObjectIfStrong(HeapObject* result) const {
64 2355498299 : if (!HasWeakHeapObjectTag(ptr_) && !IsSmi()) {
65 423438736 : *result = HeapObject::cast(Object(ptr_));
66 423438736 : return true;
67 : }
68 : return false;
69 : }
70 :
71 1089673445 : HeapObject MaybeObject::GetHeapObjectAssumeStrong() const {
72 : DCHECK(IsStrong());
73 2179346922 : return HeapObject::cast(Object(ptr_));
74 : }
75 :
76 913 : bool MaybeObject::IsWeak() const {
77 1498675125 : return HasWeakHeapObjectTag(ptr_) && !IsCleared();
78 : }
79 :
80 20 : bool MaybeObject::IsWeakOrCleared() const { return HasWeakHeapObjectTag(ptr_); }
81 :
82 581072925 : bool MaybeObject::GetHeapObjectIfWeak(HeapObject* result) const {
83 581072925 : if (IsWeak()) {
84 162459642 : *result = GetHeapObject();
85 162477935 : return true;
86 : }
87 : return false;
88 : }
89 :
90 : HeapObject MaybeObject::GetHeapObjectAssumeWeak() const {
91 : DCHECK(IsWeak());
92 79322755 : return GetHeapObject();
93 : }
94 :
95 1200425607 : HeapObject MaybeObject::GetHeapObject() const {
96 : DCHECK(!IsSmi());
97 : DCHECK(!IsCleared());
98 2403439756 : return HeapObject::cast(Object(ptr_ & ~kWeakHeapObjectMask));
99 : }
100 :
101 26378 : Object MaybeObject::GetHeapObjectOrSmi() const {
102 26378 : if (IsSmi()) {
103 24170 : return Object(ptr_);
104 : }
105 2208 : return GetHeapObject();
106 : }
107 :
108 1139602 : bool MaybeObject::IsObject() const { return IsSmi() || IsStrong(); }
109 :
110 : MaybeObject MaybeObject::MakeWeak(MaybeObject object) {
111 : DCHECK(object.IsStrongOrWeak());
112 65223 : return MaybeObject(object.ptr_ | kWeakHeapObjectMask);
113 : }
114 :
115 : // static
116 : HeapObjectReference HeapObjectReference::ClearedValue(Isolate* isolate) {
117 : // Construct cleared weak ref value.
118 : Address raw_value = kClearedWeakHeapObjectLower32;
119 : #ifdef V8_COMPRESS_POINTERS
120 : // This is necessary to make pointer decompression computation also
121 : // suitable for cleared weak references.
122 : Address isolate_root = isolate->isolate_root();
123 : raw_value |= isolate_root;
124 : DCHECK_EQ(raw_value & (~static_cast<Address>(kClearedWeakHeapObjectLower32)),
125 : isolate_root);
126 : #endif
127 : // The rest of the code will check only the lower 32-bits.
128 : DCHECK_EQ(kClearedWeakHeapObjectLower32, static_cast<uint32_t>(raw_value));
129 10162894 : return HeapObjectReference(raw_value);
130 : }
131 :
132 : template <typename THeapObjectSlot>
133 : void HeapObjectReference::Update(THeapObjectSlot slot, HeapObject value) {
134 : static_assert(std::is_same<THeapObjectSlot, FullHeapObjectSlot>::value ||
135 : std::is_same<THeapObjectSlot, HeapObjectSlot>::value,
136 : "Only FullHeapObjectSlot and HeapObjectSlot are expected here");
137 148526670 : Address old_value = (*slot).ptr();
138 : DCHECK(!HAS_SMI_TAG(old_value));
139 148246238 : Address new_value = value->ptr();
140 : DCHECK(Internals::HasHeapObjectTag(new_value));
141 :
142 : #ifdef DEBUG
143 : bool weak_before = HasWeakHeapObjectTag(old_value);
144 : #endif
145 :
146 148145625 : slot.store(
147 : HeapObjectReference(new_value | (old_value & kWeakHeapObjectMask)));
148 :
149 : #ifdef DEBUG
150 : bool weak_after = HasWeakHeapObjectTag((*slot).ptr());
151 : DCHECK_EQ(weak_before, weak_after);
152 : #endif
153 : }
154 :
155 : } // namespace internal
156 : } // namespace v8
157 :
158 : #endif // V8_OBJECTS_MAYBE_OBJECT_INL_H_
|
