v8
V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++.
Loading...
Searching...
No Matches
tagged-field-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_TAGGED_FIELD_INL_H_
6#define V8_OBJECTS_TAGGED_FIELD_INL_H_
7
8#include "src/objects/tagged-field.h"
9// Include the non-inl header before the rest of the headers.
10
11#include "src/common/ptr-compr-inl.h"
12#include "src/heap/heap-write-barrier-inl.h"
13#include "src/objects/tagged.h"
14
15namespace v8 {
16namespace internal {
17
18// static
19template <typename T, typename CompressionScheme>
20Address TaggedMember<T, CompressionScheme>::tagged_to_full(
21 Tagged_t tagged_value) {
22#ifdef V8_COMPRESS_POINTERS
23 if constexpr (std::is_same_v<Smi, T>) {
24 DCHECK(HAS_SMI_TAG(tagged_value));
25 return CompressionScheme::DecompressTaggedSigned(tagged_value);
26 } else {
27 return CompressionScheme::DecompressTagged(CompressionScheme::base(),
28 tagged_value);
29 }
30#else
31 return tagged_value;
32#endif
33}
34
35// static
36template <typename T, typename CompressionScheme>
37Tagged_t TaggedMember<T, CompressionScheme>::full_to_tagged(Address value) {
38#ifdef V8_COMPRESS_POINTERS
39 return CompressionScheme::CompressObject(value);
40#else
41 return value;
42#endif
43}
44
45template <typename T, typename CompressionScheme>
46Tagged<T> TaggedMember<T, CompressionScheme>::load() const {
47 return Tagged<T>(tagged_to_full(ptr()));
48}
49
50template <typename T, typename CompressionScheme>
51void TaggedMember<T, CompressionScheme>::store(HeapObjectLayout* host,
52 Tagged<T> value,
53 WriteBarrierMode mode) {
54 store_no_write_barrier(value);
55 WriteBarrier(host, value, mode);
56}
57
58template <typename T, typename CompressionScheme>
59Tagged<T> TaggedMember<T, CompressionScheme>::Relaxed_Load() const {
60 return Tagged<T>(
61 tagged_to_full(AsAtomicTagged::Relaxed_Load(this->ptr_location())));
62}
63
64template <typename T, typename CompressionScheme>
65void TaggedMember<T, CompressionScheme>::Relaxed_Store(HeapObjectLayout* host,
66 Tagged<T> value,
67 WriteBarrierMode mode) {
68 Relaxed_Store_no_write_barrier(value);
69 WriteBarrier(host, value, mode);
70}
71
72template <typename T, typename CompressionScheme>
73Tagged<T> TaggedMember<T, CompressionScheme>::Acquire_Load() const {
74 return Tagged<T>(
75 tagged_to_full(AsAtomicTagged::Acquire_Load(this->ptr_location())));
76}
77
78template <typename T, typename CompressionScheme>
79void TaggedMember<T, CompressionScheme>::Release_Store(HeapObjectLayout* host,
80 Tagged<T> value,
81 WriteBarrierMode mode) {
82 Release_Store_no_write_barrier(value);
83 WriteBarrier(host, value, mode);
84}
85
86template <typename T, typename CompressionScheme>
87Tagged<T> TaggedMember<T, CompressionScheme>::SeqCst_Load() const {
88 return Tagged<T>(
89 tagged_to_full(AsAtomicTagged::SeqCst_Load(this->ptr_location())));
90}
91
92template <typename T, typename CompressionScheme>
93void TaggedMember<T, CompressionScheme>::SeqCst_Store(HeapObjectLayout* host,
94 Tagged<T> value,
95 WriteBarrierMode mode) {
96 SeqCst_Store_no_write_barrier(value);
97 WriteBarrier(host, value, mode);
98}
99
100template <typename T, typename CompressionScheme>
101Tagged<T> TaggedMember<T, CompressionScheme>::SeqCst_Swap(
102 HeapObjectLayout* host, Tagged<T> value, WriteBarrierMode mode) {
103 Tagged<T> old_value(tagged_to_full(AsAtomicTagged::SeqCst_Swap(
104 this->ptr_location(), full_to_tagged(value.ptr()))));
105 WriteBarrier(host, value, mode);
106 return old_value;
107}
108
109template <typename T, typename CompressionScheme>
110Tagged<T> TaggedMember<T, CompressionScheme>::SeqCst_CompareAndSwap(
111 HeapObjectLayout* host, Tagged<T> expected_value, Tagged<T> value,
112 WriteBarrierMode mode) {
113 Tagged<T> old_value(tagged_to_full(AsAtomicTagged::SeqCst_CompareAndSwap(
114 this->ptr_location(), full_to_tagged(expected_value.ptr()),
115 full_to_tagged(value.ptr()))));
116 if (old_value == expected_value) {
117 WriteBarrier(host, value, mode);
118 }
119 return old_value;
120}
121
122template <typename T, typename CompressionScheme>
123void TaggedMember<T, CompressionScheme>::store_no_write_barrier(
124 Tagged<T> value) {
125#ifdef V8_ATOMIC_OBJECT_FIELD_WRITES
126 Relaxed_Store_no_write_barrier(value);
127#else
128 *this->ptr_location() = full_to_tagged(value.ptr());
129#endif
130}
131
132template <typename T, typename CompressionScheme>
133void TaggedMember<T, CompressionScheme>::Relaxed_Store_no_write_barrier(
134 Tagged<T> value) {
135 AsAtomicTagged::Relaxed_Store(this->ptr_location(),
136 full_to_tagged(value.ptr()));
137}
138
139template <typename T, typename CompressionScheme>
140void TaggedMember<T, CompressionScheme>::Release_Store_no_write_barrier(
141 Tagged<T> value) {
142 AsAtomicTagged::Release_Store(this->ptr_location(),
143 full_to_tagged(value.ptr()));
144}
145
146template <typename T, typename CompressionScheme>
147void TaggedMember<T, CompressionScheme>::SeqCst_Store_no_write_barrier(
148 Tagged<T> value) {
149 AsAtomicTagged::SeqCst_Store(this->ptr_location(),
150 full_to_tagged(value.ptr()));
151}
152
153template <typename T, typename CompressionScheme>
154void TaggedMember<T, CompressionScheme>::WriteBarrier(HeapObjectLayout* host,
155 Tagged<T> value,
156 WriteBarrierMode mode) {
157#ifndef V8_DISABLE_WRITE_BARRIERS
158 if constexpr (!std::is_same_v<Smi, T>) {
159#if V8_ENABLE_UNCONDITIONAL_WRITE_BARRIERS
160 mode = UPDATE_WRITE_BARRIER;
161#endif
162 DCHECK(HeapLayout::IsOwnedByAnyHeap(Tagged(host)));
163 WriteBarrier::ForValue(host, this, value, mode);
164 }
165#endif
166}
167
168// static
169template <typename T, int kFieldOffset, typename CompressionScheme>
174
175// static
176template <typename T, int kFieldOffset, typename CompressionScheme>
177Tagged_t* TaggedField<T, kFieldOffset, CompressionScheme>::location(
178 Tagged<HeapObject> host, int offset) {
179 return reinterpret_cast<Tagged_t*>(address(host, offset));
180}
181
182// static
183template <typename T, int kFieldOffset, typename CompressionScheme>
184template <typename TOnHeapAddress>
185Address TaggedField<T, kFieldOffset, CompressionScheme>::tagged_to_full(
186 TOnHeapAddress on_heap_addr, Tagged_t tagged_value) {
187#ifdef V8_COMPRESS_POINTERS
188 if constexpr (kIsSmi) {
189 DCHECK(HAS_SMI_TAG(tagged_value));
190 return CompressionScheme::DecompressTaggedSigned(tagged_value);
191 } else {
192 return CompressionScheme::DecompressTagged(on_heap_addr, tagged_value);
193 }
194#else
195 return tagged_value;
196#endif
197}
198
199// static
200template <typename T, int kFieldOffset, typename CompressionScheme>
201Tagged_t TaggedField<T, kFieldOffset, CompressionScheme>::full_to_tagged(
202 Address value) {
203#ifdef V8_COMPRESS_POINTERS
204 if constexpr (kIsSmi) DCHECK(HAS_SMI_TAG(value));
205 return CompressionScheme::CompressObject(value);
206#else
207 return value;
208#endif
209}
210
211// static
212template <typename T, int kFieldOffset, typename CompressionScheme>
213typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
214TaggedField<T, kFieldOffset, CompressionScheme>::load(Tagged<HeapObject> host,
215 int offset) {
216 Tagged_t value = *location(host, offset);
217 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
218 return PtrType(tagged_to_full(host.ptr(), value));
219}
220
221// static
222template <typename T, int kFieldOffset, typename CompressionScheme>
223typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
224TaggedField<T, kFieldOffset, CompressionScheme>::load(
225 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset) {
226 Tagged_t value = *location(host, offset);
227 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
228 return PtrType(tagged_to_full(cage_base, value));
229}
230
231// static
232template <typename T, int kFieldOffset, typename CompressionScheme>
233void TaggedField<T, kFieldOffset, CompressionScheme>::store(
234 Tagged<HeapObject> host, PtrType value) {
235#ifdef V8_ATOMIC_OBJECT_FIELD_WRITES
236 Relaxed_Store(host, value);
237#else
238 Address ptr = value.ptr();
239 DCHECK_NE(kFieldOffset, HeapObject::kMapOffset);
240 *location(host) = full_to_tagged(ptr);
241#endif
242}
243
244// static
245template <typename T, int kFieldOffset, typename CompressionScheme>
246void TaggedField<T, kFieldOffset, CompressionScheme>::store(
247 Tagged<HeapObject> host, int offset, PtrType value) {
248#ifdef V8_ATOMIC_OBJECT_FIELD_WRITES
249 Relaxed_Store(host, offset, value);
250#else
251 Address ptr = value.ptr();
252 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
253 *location(host, offset) = full_to_tagged(ptr);
254#endif
255}
256
257// static
258template <typename T, int kFieldOffset, typename CompressionScheme>
259typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
260TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_Load(
261 Tagged<HeapObject> host, int offset) {
262 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location(host, offset));
263 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
264 return PtrType(tagged_to_full(host.ptr(), value));
265}
266
267// static
268template <typename T, int kFieldOffset, typename CompressionScheme>
269typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
270TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_Load(
271 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset) {
272 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location(host, offset));
273 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
274 return PtrType(tagged_to_full(cage_base, value));
275}
276
277// static
278template <typename T, int kFieldOffset, typename CompressionScheme>
279typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
280TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_Load_Map_Word(
281 PtrComprCageBase cage_base, Tagged<HeapObject> host) {
282 AtomicTagged_t value = AsAtomicTagged::Relaxed_Load(location(host, 0));
283 return PtrType(tagged_to_full(cage_base, value));
284}
285
286// static
287template <typename T, int kFieldOffset, typename CompressionScheme>
292
293// static
294template <typename T, int kFieldOffset, typename CompressionScheme>
295void TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_Store(
296 Tagged<HeapObject> host, PtrType value) {
297 Address ptr = value.ptr();
298 DCHECK_NE(kFieldOffset, HeapObject::kMapOffset);
299 AsAtomicTagged::Relaxed_Store(location(host), full_to_tagged(ptr));
300}
301
302// static
303template <typename T, int kFieldOffset, typename CompressionScheme>
304void TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_Store(
305 Tagged<HeapObject> host, int offset, PtrType value) {
306 Address ptr = value.ptr();
307 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
308 AsAtomicTagged::Relaxed_Store(location(host, offset), full_to_tagged(ptr));
309}
310
311// static
312template <typename T, int kFieldOffset, typename CompressionScheme>
313typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
314TaggedField<T, kFieldOffset, CompressionScheme>::Acquire_Load(
315 Tagged<HeapObject> host, int offset) {
316 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location(host, offset));
317 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
318 return PtrType(tagged_to_full(host.ptr(), value));
319}
320
321// static
322template <typename T, int kFieldOffset, typename CompressionScheme>
323typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
324TaggedField<T, kFieldOffset, CompressionScheme>::Acquire_Load_No_Unpack(
325 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset) {
326 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location(host, offset));
327 return PtrType(tagged_to_full(cage_base, value));
328}
329
330template <typename T, int kFieldOffset, typename CompressionScheme>
331typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
332TaggedField<T, kFieldOffset, CompressionScheme>::Acquire_Load(
333 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset) {
334 AtomicTagged_t value = AsAtomicTagged::Acquire_Load(location(host, offset));
335 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
336 return PtrType(tagged_to_full(cage_base, value));
337}
338
339// static
340template <typename T, int kFieldOffset, typename CompressionScheme>
341void TaggedField<T, kFieldOffset, CompressionScheme>::Release_Store(
342 Tagged<HeapObject> host, PtrType value) {
343 Address ptr = value.ptr();
344 DCHECK_NE(kFieldOffset, HeapObject::kMapOffset);
345 AsAtomicTagged::Release_Store(location(host), full_to_tagged(ptr));
346}
347
348// static
349template <typename T, int kFieldOffset, typename CompressionScheme>
350void TaggedField<T, kFieldOffset, CompressionScheme>::Release_Store_Map_Word(
351 Tagged<HeapObject> host, PtrType value) {
352 Address ptr = value.ptr();
353 AsAtomicTagged::Release_Store(location(host), full_to_tagged(ptr));
354}
355
356// static
357template <typename T, int kFieldOffset, typename CompressionScheme>
358void TaggedField<T, kFieldOffset, CompressionScheme>::Release_Store(
359 Tagged<HeapObject> host, int offset, PtrType value) {
360 Address ptr = value.ptr();
361 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
362 AsAtomicTagged::Release_Store(location(host, offset), full_to_tagged(ptr));
363}
364
365// static
366template <typename T, int kFieldOffset, typename CompressionScheme>
367Tagged_t
368TaggedField<T, kFieldOffset, CompressionScheme>::Release_CompareAndSwap(
369 Tagged<HeapObject> host, PtrType old, PtrType value) {
370 Tagged_t old_value = full_to_tagged(old.ptr());
371 Tagged_t new_value = full_to_tagged(value.ptr());
372 Tagged_t result = AsAtomicTagged::Release_CompareAndSwap(
373 location(host), old_value, new_value);
374 return result;
375}
376
377// static
378template <typename T, int kFieldOffset, typename CompressionScheme>
379Tagged_t
380TaggedField<T, kFieldOffset, CompressionScheme>::Relaxed_CompareAndSwap(
381 Tagged<HeapObject> host, PtrType old, PtrType value) {
382 Tagged_t old_value = full_to_tagged(old.ptr());
383 Tagged_t new_value = full_to_tagged(value.ptr());
384 Tagged_t result = AsAtomicTagged::Relaxed_CompareAndSwap(
385 location(host), old_value, new_value);
386 return result;
387}
388
389// static
390template <typename T, int kFieldOffset, typename CompressionScheme>
391typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
392TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Load(
393 Tagged<HeapObject> host, int offset) {
394 AtomicTagged_t value = AsAtomicTagged::SeqCst_Load(location(host, offset));
395 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
396 return PtrType(tagged_to_full(host.ptr(), value));
397}
398
399// static
400template <typename T, int kFieldOffset, typename CompressionScheme>
401typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
402TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Load(
403 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset) {
404 AtomicTagged_t value = AsAtomicTagged::SeqCst_Load(location(host, offset));
405 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
406 return PtrType(tagged_to_full(cage_base, value));
407}
408
409// static
410template <typename T, int kFieldOffset, typename CompressionScheme>
411void TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Store(
412 Tagged<HeapObject> host, PtrType value) {
413 Address ptr = value.ptr();
414 DCHECK_NE(kFieldOffset, HeapObject::kMapOffset);
415 AsAtomicTagged::SeqCst_Store(location(host), full_to_tagged(ptr));
416}
417
418// static
419template <typename T, int kFieldOffset, typename CompressionScheme>
420void TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Store(
421 Tagged<HeapObject> host, int offset, PtrType value) {
422 Address ptr = value.ptr();
423 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
424 AsAtomicTagged::SeqCst_Store(location(host, offset), full_to_tagged(ptr));
425}
426
427// static
428template <typename T, int kFieldOffset, typename CompressionScheme>
429
430typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
431TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Swap(
432 Tagged<HeapObject> host, int offset, PtrType value) {
433 Address ptr = value.ptr();
434 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
435 AtomicTagged_t old_value =
436 AsAtomicTagged::SeqCst_Swap(location(host, offset), full_to_tagged(ptr));
437 return PtrType(tagged_to_full(host.ptr(), old_value));
438}
439
440// static
441template <typename T, int kFieldOffset, typename CompressionScheme>
442
443typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
444TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_Swap(
445 PtrComprCageBase cage_base, Tagged<HeapObject> host, int offset,
446 PtrType value) {
447 Address ptr = value.ptr();
448 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
449 AtomicTagged_t old_value =
450 AsAtomicTagged::SeqCst_Swap(location(host, offset), full_to_tagged(ptr));
451 return PtrType(tagged_to_full(cage_base, old_value));
452}
453
454// static
455template <typename T, int kFieldOffset, typename CompressionScheme>
456typename TaggedField<T, kFieldOffset, CompressionScheme>::PtrType
457TaggedField<T, kFieldOffset, CompressionScheme>::SeqCst_CompareAndSwap(
458 Tagged<HeapObject> host, int offset, PtrType old, PtrType value) {
459 Address ptr = value.ptr();
460 Address old_ptr = old.ptr();
461 DCHECK_NE(kFieldOffset + offset, HeapObject::kMapOffset);
462 AtomicTagged_t old_value = AsAtomicTagged::SeqCst_CompareAndSwap(
463 location(host, offset), full_to_tagged(old_ptr), full_to_tagged(ptr));
464 return TaggedField<T, kFieldOffset, CompressionScheme>::PtrType(
465 tagged_to_full(host.ptr(), old_value));
466}
467
468} // namespace internal
469} // namespace v8
470
471#endif // V8_OBJECTS_TAGGED_FIELD_INL_H_
v8::base::AsAtomicImpl::Relaxed_CompareAndSwap
static T Relaxed_CompareAndSwap(T *addr, typename std::remove_reference< T >::type old_value, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:134
v8::base::AsAtomicImpl::Release_Store
static void Release_Store(T *addr, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:100
v8::base::AsAtomicImpl::SeqCst_Store
static void SeqCst_Store(T *addr, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:92
v8::base::AsAtomicImpl::Acquire_Load
static T Acquire_Load(T *addr)
Definition atomic-utils.h:78
v8::base::AsAtomicImpl::Relaxed_Store
static void Relaxed_Store(T *addr, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:108
v8::base::AsAtomicImpl::Release_CompareAndSwap
static T Release_CompareAndSwap(T *addr, typename std::remove_reference< T >::type old_value, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:124
v8::base::AsAtomicImpl::SeqCst_Swap
static T SeqCst_Swap(T *addr, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:116
v8::base::AsAtomicImpl::SeqCst_Load
static T SeqCst_Load(T *addr)
Definition atomic-utils.h:71
v8::base::AsAtomicImpl::SeqCst_CompareAndSwap
static T SeqCst_CompareAndSwap(T *addr, typename std::remove_reference< T >::type old_value, typename std::remove_reference< T >::type new_value)
Definition atomic-utils.h:154
v8::base::AsAtomicImpl::Relaxed_Load
static T Relaxed_Load(T *addr)
Definition atomic-utils.h:85
v8::internal::HeapLayout::IsOwnedByAnyHeap
static V8_INLINE bool IsOwnedByAnyHeap(Tagged< HeapObject > object)
Definition heap-layout-inl.h:96
v8::internal::HeapObject::kMapOffset
static constexpr int kMapOffset
Definition heap-object.h:491
v8::internal::TaggedField::SeqCst_Store
static void SeqCst_Store(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:411
v8::internal::TaggedField::Relaxed_CompareAndSwap
static Tagged_t Relaxed_CompareAndSwap(Tagged< HeapObject > host, PtrType old, PtrType value)
Definition tagged-field-inl.h:380
v8::internal::TaggedField::Release_Store
static void Release_Store(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:341
v8::internal::TaggedField::PtrType
std::conditional_t< std::is_same_v< MapWord, T >, MapWord, Tagged< T > > PtrType
Definition tagged-field.h:192
v8::internal::TaggedField::load
static PtrType load(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:214
v8::internal::TaggedField::Relaxed_Store
static void Relaxed_Store(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:295
v8::internal::TaggedField::Relaxed_Store_Map_Word
static void Relaxed_Store_Map_Word(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:288
v8::internal::TaggedField::Relaxed_Load
static PtrType Relaxed_Load(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:260
v8::internal::TaggedField::address
static Address address(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:170
v8::internal::TaggedField::full_to_tagged
static Tagged_t full_to_tagged(Address value)
Definition tagged-field-inl.h:201
v8::internal::TaggedField::Acquire_Load_No_Unpack
static PtrType Acquire_Load_No_Unpack(PtrComprCageBase cage_base, Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:324
v8::internal::TaggedField::SeqCst_CompareAndSwap
static PtrType SeqCst_CompareAndSwap(Tagged< HeapObject > host, int offset, PtrType old, PtrType value)
Definition tagged-field-inl.h:457
v8::internal::TaggedField::store
static void store(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:233
v8::internal::TaggedField::Release_CompareAndSwap
static Tagged_t Release_CompareAndSwap(Tagged< HeapObject > host, PtrType old, PtrType value)
Definition tagged-field-inl.h:368
v8::internal::TaggedField::location
static Tagged_t * location(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:177
v8::internal::TaggedField::Acquire_Load
static PtrType Acquire_Load(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:314
v8::internal::TaggedField::SeqCst_Load
static PtrType SeqCst_Load(Tagged< HeapObject > host, int offset=0)
Definition tagged-field-inl.h:392
v8::internal::TaggedField::tagged_to_full
static Address tagged_to_full(TOnHeapAddress on_heap_addr, Tagged_t tagged_value)
Definition tagged-field-inl.h:185
v8::internal::TaggedField::SeqCst_Swap
static PtrType SeqCst_Swap(Tagged< HeapObject > host, int offset, PtrType value)
Definition tagged-field-inl.h:431
v8::internal::TaggedField::Release_Store_Map_Word
static void Release_Store_Map_Word(Tagged< HeapObject > host, PtrType value)
Definition tagged-field-inl.h:350
v8::internal::TaggedField::Relaxed_Load_Map_Word
static PtrType Relaxed_Load_Map_Word(PtrComprCageBase cage_base, Tagged< HeapObject > host)
Definition tagged-field-inl.h:280
v8::internal::TaggedImpl::ptr
V8_INLINE constexpr StorageType ptr() const
Definition tagged-impl.h:114
v8::internal::TaggedMember::SeqCst_Load
Tagged< T > SeqCst_Load() const
Definition tagged-field-inl.h:87
v8::internal::TaggedMember::Relaxed_Load
Tagged< T > Relaxed_Load() const
Definition tagged-field-inl.h:59
v8::internal::TaggedMember::store
void store(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:51
v8::internal::TaggedMember::SeqCst_Swap
Tagged< T > SeqCst_Swap(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:101
v8::internal::TaggedMember::SeqCst_Store_no_write_barrier
void SeqCst_Store_no_write_barrier(Tagged< T > value)
Definition tagged-field-inl.h:147
v8::internal::TaggedMember::Relaxed_Store_no_write_barrier
void Relaxed_Store_no_write_barrier(Tagged< T > value)
Definition tagged-field-inl.h:133
v8::internal::TaggedMember::SeqCst_CompareAndSwap
Tagged< T > SeqCst_CompareAndSwap(HeapObjectLayout *host, Tagged< T > expected_value, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:110
v8::internal::TaggedMember::store_no_write_barrier
void store_no_write_barrier(Tagged< T > value)
Definition tagged-field-inl.h:123
v8::internal::TaggedMember::Release_Store_no_write_barrier
void Release_Store_no_write_barrier(Tagged< T > value)
Definition tagged-field-inl.h:140
v8::internal::TaggedMember::tagged_to_full
static Address tagged_to_full(Tagged_t tagged_value)
Definition tagged-field-inl.h:20
v8::internal::TaggedMember::SeqCst_Store
void SeqCst_Store(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:93
v8::internal::TaggedMember::Release_Store
void Release_Store(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:79
v8::internal::TaggedMember::WriteBarrier
void WriteBarrier(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode)
Definition tagged-field-inl.h:154
v8::internal::TaggedMember::Acquire_Load
Tagged< T > Acquire_Load() const
Definition tagged-field-inl.h:73
v8::internal::TaggedMember::Relaxed_Store
void Relaxed_Store(HeapObjectLayout *host, Tagged< T > value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)
Definition tagged-field-inl.h:65
v8::internal::TaggedMember::full_to_tagged
static Tagged_t full_to_tagged(Address value)
Definition tagged-field-inl.h:37
v8::internal::WriteBarrier::ForValue
static void ForValue(Tagged< HeapObject > host, MaybeObjectSlot slot, Tagged< T > value, WriteBarrierMode mode)
Definition heap-write-barrier-inl.h:107
HAS_SMI_TAG
#define HAS_SMI_TAG(value)
Definition globals.h:1771
offset
int32_t offset
Definition instruction-selector-ia32.cc:67
result
ZoneVector< RpoNumber > & result
Definition jump-threading.cc:21
v8::internal::UPDATE_WRITE_BARRIER
@ UPDATE_WRITE_BARRIER
Definition objects.h:55
v8::internal::Tagged
Tagged(T object) -> Tagged< T >
v8::internal::Tagged_t
Address Tagged_t
Definition globals.h:547
v8::internal::AtomicTagged_t
base::AtomicWord AtomicTagged_t
Definition globals.h:548
v8::internal::value
return value
Definition map-inl.h:893
DCHECK_NE
#define DCHECK_NE(v1, v2)
Definition logging.h:486
DCHECK
#define DCHECK(condition)
Definition logging.h:482