Lines Matching defs:slot
47 #include "src/heap/slot-set.h"
104 virtual void VerifyCodePointer(CodeObjectSlot slot) = 0;
121 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
123 VerifyCodePointer(slot);
251 void VerifyCodePointer(CodeObjectSlot slot) override {
253 Object maybe_code = slot.load(code_cage_base());
255 // The slot might contain smi during CodeDataContainer creation, so skip it.
293 for (TSlot slot = start; slot < end; ++slot) {
294 typename TSlot::TObject object = slot.load(cage_base());
320 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
322 VerifyCodePointer(slot);
343 virtual void VerifyCodePointer(CodeObjectSlot slot) = 0;
436 void VerifyCodePointer(CodeObjectSlot slot) override {
438 Object maybe_code = slot.load(code_cage_base());
440 // The slot might contain smi during CodeDataContainer creation, so skip it.
845 // of a GC all evacuation candidates are cleared and their slot buffers are
1190 // The map slot should be handled in VisitMapPointer.
1197 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
1199 MarkObject(host, slot.load(code_cage_base()));
1257 // The map slot should be handled in VisitMapPointer.
1264 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
1266 MarkObject(host, ObjectSlot(slot.address()), slot.load(code_cage_base()));
1272 // The map slot should be handled in VisitMapPointer.
1289 V8_INLINE void MarkObject(HeapObject host, ObjectSlot slot, Object object) {
1295 MemoryChunk::FromHeapObject(host), slot.address());
1465 inline void VisitCodePointer(HeapObject host, CodeObjectSlot slot) final {
1468 // new kind of slot.
1469 DCHECK(!HasWeakHeapObjectTag(slot.load(code_cage_base())));
1470 Object code = slot.load(code_cage_base());
1471 RecordMigratedSlot(host, MaybeObject::FromObject(code), slot.address());
1495 // The target is always in old space, we don't have to record the slot in
1519 Address slot) {
1529 RememberedSet<OLD_TO_NEW>::Insert<AccessMode::NON_ATOMIC>(chunk, slot);
1534 MemoryChunk::FromHeapObject(host), slot);
1537 MemoryChunk::FromHeapObject(host), slot);
2631 isolate(), [](HeapObject object, ObjectSlot slot, HeapObject target) {
2632 RecordSlot(object, slot, target);
2672 [](HeapObject object, ObjectSlot slot, HeapObject target) {
2673 RecordSlot(object, slot, target);
2731 // Now record the slot, which has either been updated to an uncompiled data,
2733 ObjectSlot slot =
2735 RecordSlot(flushing_candidate, slot, HeapObject::cast(*slot));
2744 auto gc_notify_updated_slot = [](HeapObject object, ObjectSlot slot,
2746 RecordSlot(object, slot, HeapObject::cast(target));
2758 auto gc_notify_updated_slot = [](HeapObject object, ObjectSlot slot,
2760 RecordSlot(object, slot, HeapObject::cast(target));
2764 // Record the code slot that has been updated either to CompileLazy,
2766 ObjectSlot slot = flushed_js_function.RawField(JSFunction::kCodeOffset);
2767 RecordSlot(flushed_js_function, slot, HeapObject::cast(*slot));
2984 std::pair<HeapObject, HeapObjectSlot> slot;
2987 while (local_weak_objects()->weak_references_local.Pop(&slot)) {
2989 // The slot could have been overwritten, so we have to treat it
2991 MaybeObjectSlot location(slot.second);
2996 RecordSlot(slot.first, HeapObjectSlot(location), value);
3016 ObjectSlot slot = weak_ref.RawField(JSWeakRef::kTargetOffset);
3017 RecordSlot(weak_ref, slot, target);
3022 auto gc_notify_updated_slot = [](HeapObject object, ObjectSlot slot,
3025 RecordSlot(object, slot, HeapObject::cast(target));
3046 ObjectSlot slot = weak_cell.RawField(WeakCell::kTargetOffset);
3047 RecordSlot(weak_cell, slot, HeapObject::cast(*slot));
3066 ObjectSlot slot = weak_cell.RawField(WeakCell::kUnregisterTokenOffset);
3067 RecordSlot(weak_cell, slot, HeapObject::cast(*slot));
3152 // attempt to store a weak reference to strong-only slot to a compilation error.
3201 TSlot slot,
3222 // Needs to be atomic for map space compaction: This slot could be a map
3223 // word which we update while loading the map word for updating the slot
3225 slot.Relaxed_Store(target);
3227 slot.Release_CompareAndSwap(old, target);
3239 TSlot slot) {
3240 typename TSlot::TObject obj = slot.Relaxed_Load(cage_base);
3243 UpdateSlot<access_mode, HeapObjectReferenceType::WEAK>(cage_base, slot, obj,
3247 cage_base, slot, obj, heap_obj);
3254 TSlot slot) {
3255 typename TSlot::TObject obj = slot.Relaxed_Load(cage_base);
3260 cage_base, slot, obj, heap_obj);
3268 PtrComprCageBase code_cage_base, CodeObjectSlot slot) {
3269 Object obj = slot.Relaxed_Load(code_cage_base);
3275 cage_base, slot, obj, heap_obj);
3279 slot.address() - CodeDataContainer::kCodeOffset));
3320 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
3323 code_cage_base(), slot);
3359 PtrComprCageBase cage_base, FullObjectSlot slot) {
3360 return UpdateStrongSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
3364 PtrComprCageBase cage_base, OffHeapObjectSlot slot) {
3365 return UpdateStrongSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
3369 PtrComprCageBase cage_base, MaybeObjectSlot slot) {
3370 return UpdateStrongSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
3374 PtrComprCageBase cage_base, ObjectSlot slot) {
3375 return UpdateStrongSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
3379 PtrComprCageBase cage_base, MaybeObjectSlot slot) {
3380 return UpdateSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
3417 void VisitCodePointer(HeapObject host, CodeObjectSlot slot) override {
3418 VerifySlot(code_cage_base(), ObjectSlot(slot.address()));
3426 void VerifySlot(PtrComprCageBase cage_base, ObjectSlot slot) {
3428 if (slot.load(cage_base).GetHeapObject(&heap_object)) {
3433 void VerifySlot(PtrComprCageBase cage_base, MaybeObjectSlot slot) {
3435 if (slot.load(cage_base).GetHeapObject(&heap_object)) {
3526 // Old-to-old slot sets must be empty after evacuation.
4328 inline SlotCallbackResult CheckAndUpdateOldToNewSlot(TSlot slot) {
4335 if (!(*slot).GetHeapObject(&heap_object)) {
4341 HeapObjectReference::Update(THeapObjectSlot(slot),
4344 bool success = (*slot).GetHeapObject(&heap_object);
4349 // Unfortunately, we do not know about the slot. It could be in a
4356 // slot has been recorded multiple times in the remembered set, or
4357 // if the slot was already updated during old->old updating.
4359 // of the slot. In the other case, the slot can just be kept.
4383 [this, &filter](MaybeObjectSlot slot) {
4384 if (!filter.IsValid(slot.address())) return REMOVE_SLOT;
4385 return CheckAndUpdateOldToNewSlot(slot);
4408 [&filter, cage_base](MaybeObjectSlot slot) {
4409 if (filter.IsValid(slot.address())) {
4410 UpdateSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
4412 // Always keep slot since all slots are dropped at once after
4437 [=](MaybeObjectSlot slot) {
4439 slot.address() - CodeDataContainer::kCodeOffset);
4443 CodeObjectSlot(slot.address()));
4459 [this](FullMaybeObjectSlot slot) {
4460 return CheckAndUpdateOldToNewSlot(slot);
4463 chunk_, [=](SlotType slot_type, Address slot) {
4465 heap_, slot_type, slot, check_and_update_old_to_new_slot_fn);
4473 Address slot) {
4478 heap_, slot_type, slot, [cage_base](FullMaybeObjectSlot slot) {
4479 return UpdateStrongSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
4481 // Always keep slot since all slots are dropped at once after iteration.
4625 // WasmStruct which races with updating a slot in Map. Since to space is
4670 [cage_base](MaybeObjectSlot slot) {
4671 return UpdateSlot<AccessMode::NON_ATOMIC>(cage_base, slot);
4678 chunk, [this](SlotType slot_type, Address slot) {
4683 heap_, slot_type, slot, [cage_base](FullMaybeObjectSlot slot) {
4685 slot);
4904 void VerifyCodePointer(CodeObjectSlot slot) override {
4932 for (TSlot slot = start; slot < end; ++slot) {
4933 typename TSlot::TObject object = slot.load(cage_base);
4982 void VerifyCodePointer(CodeObjectSlot slot) override {
4984 Object maybe_code = slot.load(code_cage_base());
4986 // The slot might contain smi during CodeDataContainer creation, so skip it.
5035 CodeObjectSlot slot) override {
5043 V8_INLINE void VisitPointer(HeapObject host, ObjectSlot slot) final {
5044 VisitPointerImpl(host, slot);
5047 V8_INLINE void VisitPointer(HeapObject host, MaybeObjectSlot slot) final {
5048 VisitPointerImpl(host, slot);
5071 for (TSlot slot = start; slot < end; ++slot) {
5072 VisitPointer(host, slot);
5077 V8_INLINE void VisitPointerImpl(HeapObject host, TSlot slot) {
5078 typename TSlot::TObject target = *slot;
5187 Address slot) final {
5196 RememberedSet<OLD_TO_NEW>::Insert<AccessMode::NON_ATOMIC>(chunk, slot);
5201 MemoryChunk::FromHeapObject(host), slot);
5204 MemoryChunk::FromHeapObject(host), slot);
5603 [this, task, &filter](MaybeObjectSlot slot) {
5604 if (!filter.IsValid(slot.address())) return REMOVE_SLOT;
5605 return CheckAndMarkObject(task, slot);
5612 chunk_, [=](SlotType slot_type, Address slot) {
5614 heap(), slot_type, slot, [this, task](FullMaybeObjectSlot slot) {
5615 return CheckAndMarkObject(task, slot);
5622 CheckAndMarkObject(YoungGenerationMarkingTask* task, TSlot slot) {
5627 MaybeObject object = *slot;