1 // Copyright 2019 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_COMPRESSED_SLOTS_INL_H_
6 #define V8_OBJECTS_COMPRESSED_SLOTS_INL_H_
7
8 #ifdef V8_COMPRESS_POINTERS
9
10 #include "src/common/ptr-compr-inl.h"
11 #include "src/objects/compressed-slots.h"
12 #include "src/objects/heap-object-inl.h"
13 #include "src/objects/maybe-object-inl.h"
14
15 namespace v8 {
16 namespace internal {
17
18 //
19 // CompressedObjectSlot implementation.
20 //
21
CompressedObjectSlot(Object * object)22 CompressedObjectSlot::CompressedObjectSlot(Object* object)
23 : SlotBase(reinterpret_cast<Address>(&object->ptr_)) {}
24
contains_value(Address raw_value)25 bool CompressedObjectSlot::contains_value(Address raw_value) const {
26 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
27 return static_cast<uint32_t>(value) ==
28 static_cast<uint32_t>(static_cast<Tagged_t>(raw_value));
29 }
30
31 Object CompressedObjectSlot::operator*() const {
32 Tagged_t value = *location();
33 return Object(DecompressTaggedAny(address(), value));
34 }
35
load(IsolateRoot isolate)36 Object CompressedObjectSlot::load(IsolateRoot isolate) const {
37 Tagged_t value = *location();
38 return Object(DecompressTaggedAny(isolate, value));
39 }
40
store(Object value)41 void CompressedObjectSlot::store(Object value) const {
42 *location() = CompressTagged(value.ptr());
43 }
44
Acquire_Load()45 Object CompressedObjectSlot::Acquire_Load() const {
46 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location());
47 return Object(DecompressTaggedAny(address(), value));
48 }
49
Relaxed_Load()50 Object CompressedObjectSlot::Relaxed_Load() const {
51 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
52 return Object(DecompressTaggedAny(address(), value));
53 }
54
Relaxed_Load(IsolateRoot isolate)55 Object CompressedObjectSlot::Relaxed_Load(IsolateRoot isolate) const {
56 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
57 return Object(DecompressTaggedAny(isolate, value));
58 }
59
Relaxed_Store(Object value)60 void CompressedObjectSlot::Relaxed_Store(Object value) const {
61 Tagged_t ptr = CompressTagged(value.ptr());
62 AsAtomicTagged::Relaxed_Store(location(), ptr);
63 }
64
Release_Store(Object value)65 void CompressedObjectSlot::Release_Store(Object value) const {
66 Tagged_t ptr = CompressTagged(value.ptr());
67 AsAtomicTagged::Release_Store(location(), ptr);
68 }
69
Release_CompareAndSwap(Object old,Object target)70 Object CompressedObjectSlot::Release_CompareAndSwap(Object old,
71 Object target) const {
72 Tagged_t old_ptr = CompressTagged(old.ptr());
73 Tagged_t target_ptr = CompressTagged(target.ptr());
74 Tagged_t result =
75 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
76 return Object(DecompressTaggedAny(address(), result));
77 }
78
79 //
80 // CompressedMaybeObjectSlot implementation.
81 //
82
83 MaybeObject CompressedMaybeObjectSlot::operator*() const {
84 Tagged_t value = *location();
85 return MaybeObject(DecompressTaggedAny(address(), value));
86 }
87
load(IsolateRoot isolate)88 MaybeObject CompressedMaybeObjectSlot::load(IsolateRoot isolate) const {
89 Tagged_t value = *location();
90 return MaybeObject(DecompressTaggedAny(isolate, value));
91 }
92
store(MaybeObject value)93 void CompressedMaybeObjectSlot::store(MaybeObject value) const {
94 *location() = CompressTagged(value.ptr());
95 }
96
Relaxed_Load()97 MaybeObject CompressedMaybeObjectSlot::Relaxed_Load() const {
98 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
99 return MaybeObject(DecompressTaggedAny(address(), value));
100 }
101
Relaxed_Load(IsolateRoot isolate)102 MaybeObject CompressedMaybeObjectSlot::Relaxed_Load(IsolateRoot isolate) const {
103 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
104 return MaybeObject(DecompressTaggedAny(isolate, value));
105 }
106
Relaxed_Store(MaybeObject value)107 void CompressedMaybeObjectSlot::Relaxed_Store(MaybeObject value) const {
108 Tagged_t ptr = CompressTagged(value.ptr());
109 AsAtomicTagged::Relaxed_Store(location(), ptr);
110 }
111
Release_CompareAndSwap(MaybeObject old,MaybeObject target)112 void CompressedMaybeObjectSlot::Release_CompareAndSwap(
113 MaybeObject old, MaybeObject target) const {
114 Tagged_t old_ptr = CompressTagged(old.ptr());
115 Tagged_t target_ptr = CompressTagged(target.ptr());
116 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
117 }
118
119 //
120 // CompressedHeapObjectSlot implementation.
121 //
122
123 HeapObjectReference CompressedHeapObjectSlot::operator*() const {
124 Tagged_t value = *location();
125 return HeapObjectReference(DecompressTaggedPointer(address(), value));
126 }
127
load(IsolateRoot isolate)128 HeapObjectReference CompressedHeapObjectSlot::load(IsolateRoot isolate) const {
129 Tagged_t value = *location();
130 return HeapObjectReference(DecompressTaggedPointer(isolate, value));
131 }
132
store(HeapObjectReference value)133 void CompressedHeapObjectSlot::store(HeapObjectReference value) const {
134 *location() = CompressTagged(value.ptr());
135 }
136
ToHeapObject()137 HeapObject CompressedHeapObjectSlot::ToHeapObject() const {
138 Tagged_t value = *location();
139 DCHECK_EQ(value & kHeapObjectTagMask, kHeapObjectTag);
140 return HeapObject::cast(Object(DecompressTaggedPointer(address(), value)));
141 }
142
StoreHeapObject(HeapObject value)143 void CompressedHeapObjectSlot::StoreHeapObject(HeapObject value) const {
144 *location() = CompressTagged(value.ptr());
145 }
146
147 //
148 // OffHeapCompressedObjectSlot implementation.
149 //
150
load(IsolateRoot isolate)151 Object OffHeapCompressedObjectSlot::load(IsolateRoot isolate) const {
152 Tagged_t value = *location();
153 return Object(DecompressTaggedAny(isolate, value));
154 }
155
store(Object value)156 void OffHeapCompressedObjectSlot::store(Object value) const {
157 *location() = CompressTagged(value.ptr());
158 }
159
Relaxed_Load(IsolateRoot isolate)160 Object OffHeapCompressedObjectSlot::Relaxed_Load(IsolateRoot isolate) const {
161 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
162 return Object(DecompressTaggedAny(isolate, value));
163 }
164
Acquire_Load(IsolateRoot isolate)165 Object OffHeapCompressedObjectSlot::Acquire_Load(IsolateRoot isolate) const {
166 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location());
167 return Object(DecompressTaggedAny(isolate, value));
168 }
169
Relaxed_Store(Object value)170 void OffHeapCompressedObjectSlot::Relaxed_Store(Object value) const {
171 Tagged_t ptr = CompressTagged(value.ptr());
172 AsAtomicTagged::Relaxed_Store(location(), ptr);
173 }
174
Release_Store(Object value)175 void OffHeapCompressedObjectSlot::Release_Store(Object value) const {
176 Tagged_t ptr = CompressTagged(value.ptr());
177 AsAtomicTagged::Release_Store(location(), ptr);
178 }
179
Release_CompareAndSwap(Object old,Object target)180 void OffHeapCompressedObjectSlot::Release_CompareAndSwap(Object old,
181 Object target) const {
182 Tagged_t old_ptr = CompressTagged(old.ptr());
183 Tagged_t target_ptr = CompressTagged(target.ptr());
184 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
185 }
186
187 } // namespace internal
188 } // namespace v8
189
190 #endif // V8_COMPRESS_POINTERS
191
192 #endif // V8_OBJECTS_COMPRESSED_SLOTS_INL_H_
193