summaryrefslogtreecommitdiff
path: root/deps/v8/src/heap/heap-write-barrier-inl.h
diff options
context:
space:
mode:
Diffstat (limited to 'deps/v8/src/heap/heap-write-barrier-inl.h')
-rw-r--r--deps/v8/src/heap/heap-write-barrier-inl.h111
1 files changed, 91 insertions, 20 deletions
diff --git a/deps/v8/src/heap/heap-write-barrier-inl.h b/deps/v8/src/heap/heap-write-barrier-inl.h
index a8137ddee4..63d16ca82d 100644
--- a/deps/v8/src/heap/heap-write-barrier-inl.h
+++ b/deps/v8/src/heap/heap-write-barrier-inl.h
@@ -11,8 +11,11 @@
#include "src/heap/heap-write-barrier.h"
#include "src/globals.h"
-#include "src/heap/heap.h"
+// TODO(jkummerow): Get rid of this by moving GetIsolateFromWritableObject
+// elsewhere.
+#include "src/isolate.h"
#include "src/objects/code.h"
+#include "src/objects/fixed-array.h"
#include "src/objects/heap-object.h"
#include "src/objects/maybe-object-inl.h"
#include "src/objects/slots.h"
@@ -20,17 +23,51 @@
namespace v8 {
namespace internal {
+// Defined in heap.cc.
+V8_EXPORT_PRIVATE bool Heap_PageFlagsAreConsistent(HeapObject object);
+V8_EXPORT_PRIVATE void Heap_GenerationalBarrierSlow(HeapObject object,
+ Address slot,
+ HeapObject value);
+V8_EXPORT_PRIVATE void Heap_MarkingBarrierSlow(HeapObject object, Address slot,
+ HeapObject value);
+V8_EXPORT_PRIVATE void Heap_WriteBarrierForCodeSlow(Code host);
+V8_EXPORT_PRIVATE void Heap_GenerationalBarrierForCodeSlow(Code host,
+ RelocInfo* rinfo,
+ HeapObject object);
+V8_EXPORT_PRIVATE void Heap_MarkingBarrierForCodeSlow(Code host,
+ RelocInfo* rinfo,
+ HeapObject object);
+V8_EXPORT_PRIVATE void Heap_GenerationalBarrierForElementsSlow(Heap* heap,
+ FixedArray array,
+ int offset,
+ int length);
+V8_EXPORT_PRIVATE void Heap_MarkingBarrierForElementsSlow(Heap* heap,
+ HeapObject object);
+V8_EXPORT_PRIVATE void Heap_MarkingBarrierForDescriptorArraySlow(
+ Heap* heap, HeapObject host, HeapObject descriptor_array,
+ int number_of_own_descriptors);
+
// Do not use these internal details anywhere outside of this file. These
// internals are only intended to shortcut write barrier checks.
namespace heap_internals {
+struct Space {
+ static constexpr uintptr_t kIdOffset = 9 * kSystemPointerSize;
+ V8_INLINE AllocationSpace identity() {
+ return *reinterpret_cast<AllocationSpace*>(reinterpret_cast<Address>(this) +
+ kIdOffset);
+ }
+};
+
struct MemoryChunk {
static constexpr uintptr_t kFlagsOffset = sizeof(size_t);
static constexpr uintptr_t kHeapOffset =
kFlagsOffset + kUIntptrSize + 4 * kSystemPointerSize;
+ static constexpr uintptr_t kOwnerOffset =
+ kHeapOffset + 2 * kSystemPointerSize;
static constexpr uintptr_t kMarkingBit = uintptr_t{1} << 18;
- static constexpr uintptr_t kFromSpaceBit = uintptr_t{1} << 3;
- static constexpr uintptr_t kToSpaceBit = uintptr_t{1} << 4;
+ static constexpr uintptr_t kFromPageBit = uintptr_t{1} << 3;
+ static constexpr uintptr_t kToPageBit = uintptr_t{1} << 4;
V8_INLINE static heap_internals::MemoryChunk* FromHeapObject(
HeapObject object) {
@@ -39,9 +76,9 @@ struct MemoryChunk {
V8_INLINE bool IsMarking() const { return GetFlags() & kMarkingBit; }
- V8_INLINE bool InNewSpace() const {
- constexpr uintptr_t kNewSpaceMask = kFromSpaceBit | kToSpaceBit;
- return GetFlags() & kNewSpaceMask;
+ V8_INLINE bool InYoungGeneration() const {
+ constexpr uintptr_t kYoungGenerationMask = kFromPageBit | kToPageBit;
+ return GetFlags() & kYoungGenerationMask;
}
V8_INLINE uintptr_t GetFlags() const {
@@ -55,30 +92,37 @@ struct MemoryChunk {
SLOW_DCHECK(heap != nullptr);
return heap;
}
+
+ V8_INLINE Space* GetOwner() {
+ return *reinterpret_cast<Space**>(reinterpret_cast<Address>(this) +
+ kOwnerOffset);
+ }
};
inline void GenerationalBarrierInternal(HeapObject object, Address slot,
HeapObject value) {
- DCHECK(Heap::PageFlagsAreConsistent(object));
+ DCHECK(Heap_PageFlagsAreConsistent(object));
heap_internals::MemoryChunk* value_chunk =
heap_internals::MemoryChunk::FromHeapObject(value);
heap_internals::MemoryChunk* object_chunk =
heap_internals::MemoryChunk::FromHeapObject(object);
- if (!value_chunk->InNewSpace() || object_chunk->InNewSpace()) return;
+ if (!value_chunk->InYoungGeneration() || object_chunk->InYoungGeneration()) {
+ return;
+ }
- Heap::GenerationalBarrierSlow(object, slot, value);
+ Heap_GenerationalBarrierSlow(object, slot, value);
}
inline void MarkingBarrierInternal(HeapObject object, Address slot,
HeapObject value) {
- DCHECK(Heap::PageFlagsAreConsistent(object));
+ DCHECK(Heap_PageFlagsAreConsistent(object));
heap_internals::MemoryChunk* value_chunk =
heap_internals::MemoryChunk::FromHeapObject(value);
if (!value_chunk->IsMarking()) return;
- Heap::MarkingBarrierSlow(object, slot, value);
+ Heap_MarkingBarrierSlow(object, slot, value);
}
} // namespace heap_internals
@@ -92,7 +136,7 @@ inline void WriteBarrierForCode(Code host, RelocInfo* rinfo, Object value) {
}
inline void WriteBarrierForCode(Code host) {
- Heap::WriteBarrierForCodeSlow(host);
+ Heap_WriteBarrierForCodeSlow(host);
}
inline void GenerationalBarrier(HeapObject object, ObjectSlot slot,
@@ -116,17 +160,17 @@ inline void GenerationalBarrierForElements(Heap* heap, FixedArray array,
int offset, int length) {
heap_internals::MemoryChunk* array_chunk =
heap_internals::MemoryChunk::FromHeapObject(array);
- if (array_chunk->InNewSpace()) return;
+ if (array_chunk->InYoungGeneration()) return;
- Heap::GenerationalBarrierForElementsSlow(heap, array, offset, length);
+ Heap_GenerationalBarrierForElementsSlow(heap, array, offset, length);
}
inline void GenerationalBarrierForCode(Code host, RelocInfo* rinfo,
HeapObject object) {
heap_internals::MemoryChunk* object_chunk =
heap_internals::MemoryChunk::FromHeapObject(object);
- if (!object_chunk->InNewSpace()) return;
- Heap::GenerationalBarrierForCodeSlow(host, rinfo, object);
+ if (!object_chunk->InYoungGeneration()) return;
+ Heap_GenerationalBarrierForCodeSlow(host, rinfo, object);
}
inline void MarkingBarrier(HeapObject object, ObjectSlot slot, Object value) {
@@ -150,7 +194,7 @@ inline void MarkingBarrierForElements(Heap* heap, HeapObject object) {
heap_internals::MemoryChunk::FromHeapObject(object);
if (!object_chunk->IsMarking()) return;
- Heap::MarkingBarrierForElementsSlow(heap, object);
+ Heap_MarkingBarrierForElementsSlow(heap, object);
}
inline void MarkingBarrierForCode(Code host, RelocInfo* rinfo,
@@ -159,7 +203,7 @@ inline void MarkingBarrierForCode(Code host, RelocInfo* rinfo,
heap_internals::MemoryChunk* object_chunk =
heap_internals::MemoryChunk::FromHeapObject(object);
if (!object_chunk->IsMarking()) return;
- Heap::MarkingBarrierForCodeSlow(host, rinfo, object);
+ Heap_MarkingBarrierForCodeSlow(host, rinfo, object);
}
inline void MarkingBarrierForDescriptorArray(Heap* heap, HeapObject host,
@@ -169,8 +213,24 @@ inline void MarkingBarrierForDescriptorArray(Heap* heap, HeapObject host,
heap_internals::MemoryChunk::FromHeapObject(descriptor_array);
if (!chunk->IsMarking()) return;
- Heap::MarkingBarrierForDescriptorArraySlow(heap, host, descriptor_array,
- number_of_own_descriptors);
+ Heap_MarkingBarrierForDescriptorArraySlow(heap, host, descriptor_array,
+ number_of_own_descriptors);
+}
+
+inline WriteBarrierMode GetWriteBarrierModeForObject(
+ HeapObject object, const DisallowHeapAllocation* promise) {
+ DCHECK(Heap_PageFlagsAreConsistent(object));
+ heap_internals::MemoryChunk* chunk =
+ heap_internals::MemoryChunk::FromHeapObject(object);
+ if (chunk->IsMarking()) return UPDATE_WRITE_BARRIER;
+ if (chunk->InYoungGeneration()) return SKIP_WRITE_BARRIER;
+ return UPDATE_WRITE_BARRIER;
+}
+
+inline bool ObjectInYoungGeneration(const Object object) {
+ if (object.IsSmi()) return false;
+ return heap_internals::MemoryChunk::FromHeapObject(HeapObject::cast(object))
+ ->InYoungGeneration();
}
inline Heap* GetHeapFromWritableObject(const HeapObject object) {
@@ -179,6 +239,17 @@ inline Heap* GetHeapFromWritableObject(const HeapObject object) {
return chunk->GetHeap();
}
+inline bool GetIsolateFromWritableObject(HeapObject obj, Isolate** isolate) {
+ heap_internals::MemoryChunk* chunk =
+ heap_internals::MemoryChunk::FromHeapObject(obj);
+ if (chunk->GetOwner()->identity() == RO_SPACE) {
+ *isolate = nullptr;
+ return false;
+ }
+ *isolate = Isolate::FromHeap(chunk->GetHeap());
+ return true;
+}
+
} // namespace internal
} // namespace v8
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-01 11:18:57 +0000