v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
compressed-slots-inl.h
Go to the documentation of this file.
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/objects/compressed-slots.h"
11// Include the non-inl header before the rest of the headers.
12
13#include "src/common/ptr-compr-inl.h"
14#include "src/objects/casting.h"
15#include "src/objects/maybe-object-inl.h"
16
17namespace v8::internal {
18
19//
20// CompressedObjectSlot implementation.
21//
22
23CompressedObjectSlot::CompressedObjectSlot(Tagged<Object>* object)
24 : SlotBase(reinterpret_cast<Address>(&object->ptr_)) {}
25
26bool CompressedObjectSlot::contains_map_value(Address raw_value) const {
27 DCHECK(!V8_MAP_PACKING_BOOL);
28 Tagged_t value = *location();
29 return static_cast<uint32_t>(value) ==
30 static_cast<uint32_t>(static_cast<Tagged_t>(raw_value));
31}
32
33bool CompressedObjectSlot::Relaxed_ContainsMapValue(Address raw_value) const {
34 DCHECK(!V8_MAP_PACKING_BOOL);
35 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
36 return static_cast<uint32_t>(value) ==
37 static_cast<uint32_t>(static_cast<Tagged_t>(raw_value));
38}
39
40Tagged<Object> CompressedObjectSlot::operator*() const {
41 Tagged_t value = *location();
42 return Tagged<Object>(TCompressionScheme::DecompressTagged(address(), value));
43}
44
45Tagged<Object> CompressedObjectSlot::load() const {
46 AtomicTagged_t value = *location();
47 return Tagged<Object>(TCompressionScheme::DecompressTagged(address(), value));
48}
49
50Tagged<Object> CompressedObjectSlot::load(PtrComprCageBase cage_base) const {
51 Tagged_t value = *location();
52 return Tagged<Object>(TCompressionScheme::DecompressTagged(cage_base, value));
53}
54
55void CompressedObjectSlot::store(Tagged<Object> value) const {
56 *location() = TCompressionScheme::CompressObject(value.ptr());
57}
58
59void CompressedObjectSlot::store_map(Tagged<Map> map) const {
60 // Simply forward to store because map packing is not supported with pointer
61 // compression.
62 DCHECK(!V8_MAP_PACKING_BOOL);
63 store(map);
64}
65
66Tagged<Map> CompressedObjectSlot::load_map() const {
67 // Simply forward to Relaxed_Load because map packing is not supported with
68 // pointer compression.
69 DCHECK(!V8_MAP_PACKING_BOOL);
70 return UncheckedCast<Map>(Relaxed_Load());
71}
72
73Tagged<Object> CompressedObjectSlot::Acquire_Load() const {
74 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location());
75 return Tagged<Object>(TCompressionScheme::DecompressTagged(address(), value));
76}
77
78Tagged<Object> CompressedObjectSlot::Relaxed_Load() const {
79 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
80 return Tagged<Object>(TCompressionScheme::DecompressTagged(address(), value));
81}
82
83Tagged<Object> CompressedObjectSlot::Relaxed_Load(
84 PtrComprCageBase cage_base) const {
85 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
86 return Tagged<Object>(TCompressionScheme::DecompressTagged(cage_base, value));
87}
88
89Tagged_t CompressedObjectSlot::Relaxed_Load_Raw() const {
90 return static_cast<Tagged_t>(AsAtomicTagged::Relaxed_Load(location()));
91}
92
93// static
94Tagged<Object> CompressedObjectSlot::RawToTagged(PtrComprCageBase cage_base,
95 Tagged_t raw) {
96 return Tagged<Object>(TCompressionScheme::DecompressTagged(cage_base, raw));
97}
98
99void CompressedObjectSlot::Relaxed_Store(Tagged<Object> value) const {
100 Tagged_t ptr = TCompressionScheme::CompressObject(value.ptr());
101 AsAtomicTagged::Relaxed_Store(location(), ptr);
102}
103
104void CompressedObjectSlot::Release_Store(Tagged<Object> value) const {
105 Tagged_t ptr = TCompressionScheme::CompressObject(value.ptr());
106 AsAtomicTagged::Release_Store(location(), ptr);
107}
108
109Tagged<Object> CompressedObjectSlot::Release_CompareAndSwap(
110 Tagged<Object> old, Tagged<Object> target) const {
111 Tagged_t old_ptr = TCompressionScheme::CompressObject(old.ptr());
112 Tagged_t target_ptr = TCompressionScheme::CompressObject(target.ptr());
113 Tagged_t result =
114 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
115 return Tagged<Object>(
116 TCompressionScheme::DecompressTagged(address(), result));
117}
118
119//
120// CompressedMaybeObjectSlot implementation.
121//
122
123Tagged<MaybeObject> CompressedMaybeObjectSlot::operator*() const {
124 Tagged_t value = *location();
125 return Tagged<MaybeObject>(
126 TCompressionScheme::DecompressTagged(address(), value));
127}
128
129Tagged<MaybeObject> CompressedMaybeObjectSlot::load() const {
130 Tagged_t value = *location();
131 return Tagged<MaybeObject>(
132 TCompressionScheme::DecompressTagged(address(), value));
133}
134
135Tagged<MaybeObject> CompressedMaybeObjectSlot::load(
136 PtrComprCageBase cage_base) const {
137 Tagged_t value = *location();
138 return Tagged<MaybeObject>(
139 TCompressionScheme::DecompressTagged(cage_base, value));
140}
141
142void CompressedMaybeObjectSlot::store(Tagged<MaybeObject> value) const {
143 *location() = TCompressionScheme::CompressObject(value.ptr());
144}
145
146Tagged<MaybeObject> CompressedMaybeObjectSlot::Relaxed_Load() const {
147 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
148 return Tagged<MaybeObject>(
149 TCompressionScheme::DecompressTagged(address(), value));
150}
151
152Tagged<MaybeObject> CompressedMaybeObjectSlot::Relaxed_Load(
153 PtrComprCageBase cage_base) const {
154 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location());
155 return Tagged<MaybeObject>(
156 TCompressionScheme::DecompressTagged(cage_base, value));
157}
158
159Tagged_t CompressedMaybeObjectSlot::Relaxed_Load_Raw() const {
160 return static_cast<Tagged_t>(AsAtomicTagged::Relaxed_Load(location()));
161}
162
163// static
164Tagged<Object> CompressedMaybeObjectSlot::RawToTagged(
165 PtrComprCageBase cage_base, Tagged_t raw) {
166 return Tagged<Object>(TCompressionScheme::DecompressTagged(cage_base, raw));
167}
168
169void CompressedMaybeObjectSlot::Relaxed_Store(Tagged<MaybeObject> value) const {
170 Tagged_t ptr = TCompressionScheme::CompressObject(value.ptr());
171 AsAtomicTagged::Relaxed_Store(location(), ptr);
172}
173
174void CompressedMaybeObjectSlot::Release_CompareAndSwap(
175 Tagged<MaybeObject> old, Tagged<MaybeObject> target) const {
176 Tagged_t old_ptr = TCompressionScheme::CompressObject(old.ptr());
177 Tagged_t target_ptr = TCompressionScheme::CompressObject(target.ptr());
178 AsAtomicTagged::Release_CompareAndSwap(location(), old_ptr, target_ptr);
179}
180
181//
182// CompressedHeapObjectSlot implementation.
183//
184
185Tagged<HeapObjectReference> CompressedHeapObjectSlot::operator*() const {
186 Tagged_t value = *location();
187 return Cast<HeapObjectReference>(Tagged<MaybeObject>(
188 TCompressionScheme::DecompressTagged(address(), value)));
189}
190
191Tagged<HeapObjectReference> CompressedHeapObjectSlot::load(
192 PtrComprCageBase cage_base) const {
193 Tagged_t value = *location();
194 return Cast<HeapObjectReference>(Tagged<MaybeObject>(
195 TCompressionScheme::DecompressTagged(cage_base, value)));
196}
197
198void CompressedHeapObjectSlot::store(Tagged<HeapObjectReference> value) const {
199 *location() = TCompressionScheme::CompressObject(value.ptr());
200}
201
202Tagged<HeapObject> CompressedHeapObjectSlot::ToHeapObject() const {
203 Tagged_t value = *location();
204 DCHECK(HAS_STRONG_HEAP_OBJECT_TAG(value));
205 return Cast<HeapObject>(
206 Tagged<Object>(TCompressionScheme::DecompressTagged(address(), value)));
207}
208
209void CompressedHeapObjectSlot::StoreHeapObject(Tagged<HeapObject> value) const {
210 *location() = TCompressionScheme::CompressObject(value.ptr());
211}
212
213//
214// OffHeapCompressedObjectSlot/OffHeapCompressedMaybeObjectSlot implementation.
215//
216
217template <typename CompressionScheme, typename TObject, typename Subclass>
218TObject OffHeapCompressedObjectSlotBase<CompressionScheme, TObject,
219 Subclass>::load() const {
220 Tagged_t value = *TSlotBase::location();
221 return TObject(
222 CompressionScheme::DecompressTagged(TSlotBase::address(), value));
223}
224
225template <typename CompressionScheme, typename TObject, typename Subclass>
226TObject
227OffHeapCompressedObjectSlotBase<CompressionScheme, TObject, Subclass>::load(
228 PtrComprCageBase cage_base) const {
229 Tagged_t value = *TSlotBase::location();
230 return TObject(CompressionScheme::DecompressTagged(cage_base, value));
231}
232
233template <typename CompressionScheme, typename TObject, typename Subclass>
234void OffHeapCompressedObjectSlotBase<CompressionScheme, TObject,
235 Subclass>::store(TObject value) const {
236 *TSlotBase::location() = CompressionScheme::CompressObject(value.ptr());
237}
238
239template <typename CompressionScheme, typename TObject, typename Subclass>
240TObject OffHeapCompressedObjectSlotBase<CompressionScheme, TObject,
241 Subclass>::Relaxed_Load() const {
242 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(TSlotBase::location());
243 return TObject(
244 CompressionScheme::DecompressTagged(TSlotBase::address(), value));
245}
246
247template <typename CompressionScheme, typename TObject, typename Subclass>
248TObject OffHeapCompressedObjectSlotBase<CompressionScheme, TObject, Subclass>::
249 Relaxed_Load(PtrComprCageBase cage_base) const {
250 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(TSlotBase::location());
251 return TObject(CompressionScheme::DecompressTagged(cage_base, value));
252}
253
254template <typename CompressionScheme, typename TObject, typename Subclass>
255Tagged_t OffHeapCompressedObjectSlotBase<CompressionScheme, TObject,
256 Subclass>::Relaxed_Load_Raw() const {
257 return static_cast<Tagged_t>(
258 AsAtomicTagged::Relaxed_Load(TSlotBase::location()));
259}
260
261// static
262template <typename CompressionScheme, typename TObject, typename Subclass>
263Tagged<Object> OffHeapCompressedObjectSlotBase<
264 CompressionScheme, TObject,
265 Subclass>::RawToTagged(PtrComprCageBase cage_base, Tagged_t raw) {
266 return Tagged<Object>(CompressionScheme::DecompressTagged(cage_base, raw));
267}
268
269template <typename CompressionScheme, typename TObject, typename Subclass>
270TObject OffHeapCompressedObjectSlotBase<CompressionScheme, TObject,
271 Subclass>::Acquire_Load() const {
272 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(TSlotBase::location());
273 return TObject(
274 CompressionScheme::DecompressTagged(TSlotBase::address(), value));
275}
276
277template <typename CompressionScheme, typename TObject, typename Subclass>
278TObject OffHeapCompressedObjectSlotBase<CompressionScheme, TObject, Subclass>::
279 Acquire_Load(PtrComprCageBase cage_base) const {
280 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(TSlotBase::location());
281 return TObject(CompressionScheme::DecompressTagged(cage_base, value));
282}
283
284template <typename CompressionScheme, typename TObject, typename Subclass>
285void OffHeapCompressedObjectSlotBase<
286 CompressionScheme, TObject, Subclass>::Relaxed_Store(TObject value) const {
287 Tagged_t ptr = CompressionScheme::CompressObject(value.ptr());
288 AsAtomicTagged::Relaxed_Store(TSlotBase::location(), ptr);
289}
290
291template <typename CompressionScheme, typename TObject, typename Subclass>
292void OffHeapCompressedObjectSlotBase<
293 CompressionScheme, TObject, Subclass>::Release_Store(TObject value) const {
294 Tagged_t ptr = CompressionScheme::CompressObject(value.ptr());
295 AsAtomicTagged::Release_Store(TSlotBase::location(), ptr);
296}
297
298template <typename CompressionScheme, typename TObject, typename Subclass>
299void OffHeapCompressedObjectSlotBase<CompressionScheme, TObject, Subclass>::
300 Release_CompareAndSwap(TObject old, TObject target) const {
301 Tagged_t old_ptr = CompressionScheme::CompressObject(old.ptr());
302 Tagged_t target_ptr = CompressionScheme::CompressObject(target.ptr());
303 AsAtomicTagged::Release_CompareAndSwap(TSlotBase::location(), old_ptr,
304 target_ptr);
305}
306
307} // namespace v8::internal
308
309#endif // V8_COMPRESS_POINTERS
310
311#endif // V8_OBJECTS_COMPRESSED_SLOTS_INL_H_
ptr_
Node ** ptr_
Definition code-assembler.cc:1214
V8_MAP_PACKING_BOOL
#define V8_MAP_PACKING_BOOL
Definition globals.h:93
HAS_STRONG_HEAP_OBJECT_TAG
#define HAS_STRONG_HEAP_OBJECT_TAG(value)
Definition globals.h:1774
store
too high values may cause the compiler to set high thresholds for inlining to as much as possible avoid inlined allocation of objects that cannot escape trace load stores from virtual maglev objects use TurboFan fast string builder analyze liveness of environment slots and zap dead values trace TurboFan load elimination emit data about basic block usage in builtins to this enable builtin reordering when run mksnapshot flag for emit warnings when applying builtin profile data verify register allocation in TurboFan randomly schedule instructions to stress dependency tracking enable store store elimination in TurboFan rewrite far to near simulate GC compiler thread race related to allow float parameters to be passed in simulator mode JS Wasm Run additional turbo_optimize_inlined_js_wasm_wrappers enable experimental feedback collection in generic lowering enable Turboshaft s WasmLoadElimination enable Turboshaft s low level load elimination for JS enable Turboshaft s escape analysis for string concatenation use enable Turbolev features that we want to ship in the not too far future trace individual Turboshaft reduction steps trace intermediate Turboshaft reduction steps invocation count threshold for early optimization Enables optimizations which favor memory size over execution speed Enables sampling allocation profiler with X as a sample interval min size of a semi the new space consists of two semi spaces max size of the Collect garbage after Collect garbage after keeps maps alive for< n > old space garbage collections print one detailed trace line in allocation gc speed threshold for starting incremental marking via a task in percent of available threshold for starting incremental marking immediately in percent of available Use a single schedule for determining a marking schedule between JS and C objects schedules the minor GC task with kUserVisible priority max worker number of concurrent for NumberOfWorkerThreads start background threads that allocate memory concurrent_array_buffer_sweeping use parallel threads to clear weak refs in the atomic pause trace progress of the incremental marking trace object counts and memory usage report a tick only when allocated zone memory changes by this amount TracingFlags::gc_stats store(v8::tracing::TracingCategoryObserver::ENABLED_BY_NATIVE)) DEFINE_GENERIC_IMPLICATION(trace_gc_object_stats
result
ZoneVector< RpoNumber > & result
Definition jump-threading.cc:21
v8::base::Relaxed_Load
Atomic8 Relaxed_Load(volatile const Atomic8 *ptr)
Definition atomicops.h:234
v8::internal::Tagged_t
Address Tagged_t
Definition globals.h:547
v8::internal::AtomicTagged_t
base::AtomicWord AtomicTagged_t
Definition globals.h:548
DCHECK
#define DCHECK(condition)
Definition logging.h:482
value
std::unique_ptr< ValueMirror > value
Definition value-mirror.cc:950