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/maybe-object-inl.h"
13
14 namespace v8 {
15 namespace internal {
16
17 //
18 // CompressedObjectSlot implementation.
19 //
20
CompressedObjectSlot(Object * object)21 CompressedObjectSlot::CompressedObjectSlot(Object* object)
22 : SlotBase(reinterpret_cast<Address>(&object->ptr_)) {}
23
contains_value(Address raw_value)24 bool CompressedObjectSlot::contains_value(Address raw_value) const {
25 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
26 return static_cast<uint32_t>(value) ==
27 static_cast<uint32_t>(static_cast<Tagged_t>(raw_value));
28 }
29
contains_map_value(Address raw_value)30 bool CompressedObjectSlot::contains_map_value(Address raw_value) const {
31 // Simply forward to contains_value because map packing is not supported with
32 // pointer compression.
33 DCHECK(!V8_MAP_PACKING_BOOL);
34 return contains_value(raw_value);
35 }
36
37 Object CompressedObjectSlot::operator*() const {
38 Tagged_t value = *location();
39 return Object(DecompressTaggedAny(address(), value));
40 }
41
load(PtrComprCageBase cage_base)42 Object CompressedObjectSlot::load(PtrComprCageBase cage_base) const {
43 Tagged_t value = *location();
44 return Object(DecompressTaggedAny(cage_base, value));
45 }
46
store(Object value)47 void CompressedObjectSlot::store(Object value) const {
48 *location() = CompressTagged(value.ptr());
49 }
50
store_map(Map map)51 void CompressedObjectSlot::store_map(Map map) const {
52 // Simply forward to store because map packing is not supported with pointer
53 // compression.
54 DCHECK(!V8_MAP_PACKING_BOOL);
55 store(map);
56 }
57
load_map()58 Map CompressedObjectSlot::load_map() const {
59 // Simply forward to Relaxed_Load because map packing is not supported with
60 // pointer compression.
61 DCHECK(!V8_MAP_PACKING_BOOL);
62 return Map::unchecked_cast(Relaxed_Load());
63 }
64
Acquire_Load()65 Object CompressedObjectSlot::Acquire_Load() const {
66 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location());
67 return Object(DecompressTaggedAny(address(), value));
68 }
69
Relaxed_Load()70 Object CompressedObjectSlot::Relaxed_Load() const {
71 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
72 return Object(DecompressTaggedAny(address(), value));
73 }
74
Relaxed_Load(PtrComprCageBase cage_base)75 Object CompressedObjectSlot::Relaxed_Load(PtrComprCageBase cage_base) const {
76 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
77 return Object(DecompressTaggedAny(cage_base, value));
78 }
79
Relaxed_Store(Object value)80 void CompressedObjectSlot::Relaxed_Store(Object value) const {
81 Tagged_t ptr = CompressTagged(value.ptr());
82 AsAtomicTagged::Relaxed_Store(location(), ptr);
83 }
84
Release_Store(Object value)85 void CompressedObjectSlot::Release_Store(Object value) const {
86 Tagged_t ptr = CompressTagged(value.ptr());
87 AsAtomicTagged::Release_Store(location(), ptr);
88 }
89
Release_CompareAndSwap(Object old,Object target)90 Object CompressedObjectSlot::Release_CompareAndSwap(Object old,
91 Object target) const {
92 Tagged_t old_ptr = CompressTagged(old.ptr());
93 Tagged_t target_ptr = CompressTagged(target.ptr());
94 Tagged_t result =
95 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
96 return Object(DecompressTaggedAny(address(), result));
97 }
98
99 //
100 // CompressedMaybeObjectSlot implementation.
101 //
102
103 MaybeObject CompressedMaybeObjectSlot::operator*() const {
104 Tagged_t value = *location();
105 return MaybeObject(DecompressTaggedAny(address(), value));
106 }
107
load(PtrComprCageBase cage_base)108 MaybeObject CompressedMaybeObjectSlot::load(PtrComprCageBase cage_base) const {
109 Tagged_t value = *location();
110 return MaybeObject(DecompressTaggedAny(cage_base, value));
111 }
112
store(MaybeObject value)113 void CompressedMaybeObjectSlot::store(MaybeObject value) const {
114 *location() = CompressTagged(value.ptr());
115 }
116
Relaxed_Load()117 MaybeObject CompressedMaybeObjectSlot::Relaxed_Load() const {
118 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
119 return MaybeObject(DecompressTaggedAny(address(), value));
120 }
121
Relaxed_Load(PtrComprCageBase cage_base)122 MaybeObject CompressedMaybeObjectSlot::Relaxed_Load(
123 PtrComprCageBase cage_base) const {
124 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
125 return MaybeObject(DecompressTaggedAny(cage_base, value));
126 }
127
Relaxed_Store(MaybeObject value)128 void CompressedMaybeObjectSlot::Relaxed_Store(MaybeObject value) const {
129 Tagged_t ptr = CompressTagged(value.ptr());
130 AsAtomicTagged::Relaxed_Store(location(), ptr);
131 }
132
Release_CompareAndSwap(MaybeObject old,MaybeObject target)133 void CompressedMaybeObjectSlot::Release_CompareAndSwap(
134 MaybeObject old, MaybeObject target) const {
135 Tagged_t old_ptr = CompressTagged(old.ptr());
136 Tagged_t target_ptr = CompressTagged(target.ptr());
137 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
138 }
139
140 //
141 // CompressedHeapObjectSlot implementation.
142 //
143
144 HeapObjectReference CompressedHeapObjectSlot::operator*() const {
145 Tagged_t value = *location();
146 return HeapObjectReference(DecompressTaggedPointer(address(), value));
147 }
148
load(PtrComprCageBase cage_base)149 HeapObjectReference CompressedHeapObjectSlot::load(
150 PtrComprCageBase cage_base) const {
151 Tagged_t value = *location();
152 return HeapObjectReference(DecompressTaggedPointer(cage_base, value));
153 }
154
store(HeapObjectReference value)155 void CompressedHeapObjectSlot::store(HeapObjectReference value) const {
156 *location() = CompressTagged(value.ptr());
157 }
158
ToHeapObject()159 HeapObject CompressedHeapObjectSlot::ToHeapObject() const {
160 Tagged_t value = *location();
161 DCHECK(HAS_STRONG_HEAP_OBJECT_TAG(value));
162 return HeapObject::cast(Object(DecompressTaggedPointer(address(), value)));
163 }
164
StoreHeapObject(HeapObject value)165 void CompressedHeapObjectSlot::StoreHeapObject(HeapObject value) const {
166 *location() = CompressTagged(value.ptr());
167 }
168
169 //
170 // OffHeapCompressedObjectSlot implementation.
171 //
172
load(PtrComprCageBase cage_base)173 Object OffHeapCompressedObjectSlot::load(PtrComprCageBase cage_base) const {
174 Tagged_t value = *location();
175 return Object(DecompressTaggedAny(cage_base, value));
176 }
177
store(Object value)178 void OffHeapCompressedObjectSlot::store(Object value) const {
179 *location() = CompressTagged(value.ptr());
180 }
181
Relaxed_Load(PtrComprCageBase cage_base)182 Object OffHeapCompressedObjectSlot::Relaxed_Load(
183 PtrComprCageBase cage_base) const {
184 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
185 return Object(DecompressTaggedAny(cage_base, value));
186 }
187
Acquire_Load(PtrComprCageBase cage_base)188 Object OffHeapCompressedObjectSlot::Acquire_Load(
189 PtrComprCageBase cage_base) const {
190 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location());
191 return Object(DecompressTaggedAny(cage_base, value));
192 }
193
Relaxed_Store(Object value)194 void OffHeapCompressedObjectSlot::Relaxed_Store(Object value) const {
195 Tagged_t ptr = CompressTagged(value.ptr());
196 AsAtomicTagged::Relaxed_Store(location(), ptr);
197 }
198
Release_Store(Object value)199 void OffHeapCompressedObjectSlot::Release_Store(Object value) const {
200 Tagged_t ptr = CompressTagged(value.ptr());
201 AsAtomicTagged::Release_Store(location(), ptr);
202 }
203
Release_CompareAndSwap(Object old,Object target)204 void OffHeapCompressedObjectSlot::Release_CompareAndSwap(Object old,
205 Object target) const {
206 Tagged_t old_ptr = CompressTagged(old.ptr());
207 Tagged_t target_ptr = CompressTagged(target.ptr());
208 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
209 }
210
211 } // namespace internal
212 } // namespace v8
213
214 #endif // V8_COMPRESS_POINTERS
215
216 #endif // V8_OBJECTS_COMPRESSED_SLOTS_INL_H_
217