1 // Copyright 2018 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_HEAP_HEAP_WRITE_BARRIER_H_ 6 #define V8_HEAP_HEAP_WRITE_BARRIER_H_ 7 8 #include "include/v8-internal.h" 9 #include "src/base/optional.h" 10 #include "src/common/globals.h" 11 #include "src/objects/heap-object.h" 12 13 namespace v8 { 14 namespace internal { 15 16 class ArrayBufferExtension; 17 class Code; 18 class DescriptorArray; 19 class EphemeronHashTable; 20 class FixedArray; 21 class Heap; 22 class JSArrayBuffer; 23 class Map; 24 class MarkCompactCollector; 25 class MarkingBarrier; 26 class RelocInfo; 27 28 // Note: In general it is preferred to use the macros defined in 29 // object-macros.h. 30 31 // Combined write barriers. 32 void WriteBarrierForCode(Code host, RelocInfo* rinfo, Object value); 33 void WriteBarrierForCode(Code host, RelocInfo* rinfo, HeapObject value); 34 void WriteBarrierForCode(Code host); 35 36 // Generational write barrier. 37 void GenerationalBarrier(HeapObject object, ObjectSlot slot, Object value); 38 void GenerationalBarrier(HeapObject object, ObjectSlot slot, Code value); 39 void GenerationalBarrier(HeapObject object, ObjectSlot slot, HeapObject value); 40 void GenerationalBarrier(HeapObject object, MaybeObjectSlot slot, 41 MaybeObject value); 42 void GenerationalEphemeronKeyBarrier(EphemeronHashTable table, ObjectSlot slot, 43 Object value); 44 void GenerationalBarrierForCode(Code host, RelocInfo* rinfo, HeapObject object); 45 46 inline bool IsReadOnlyHeapObject(HeapObject object); 47 48 class V8_EXPORT_PRIVATE WriteBarrier { 49 public: 50 static inline void Marking(HeapObject host, ObjectSlot, Object value); 51 static inline void Marking(HeapObject host, HeapObjectSlot, HeapObject value); 52 static inline void Marking(HeapObject host, MaybeObjectSlot, 53 MaybeObject value); 54 static inline void Marking(Code host, RelocInfo*, HeapObject value); 55 static inline void Marking(JSArrayBuffer host, ArrayBufferExtension*); 56 static inline void Marking(DescriptorArray, int number_of_own_descriptors); 57 // It is invoked from generated code and has to take raw addresses. 58 static int MarkingFromCode(Address raw_host, Address raw_slot); 59 // Invoked from global handles where no host object is available. 60 static inline void MarkingFromGlobalHandle(Object value); 61 static inline void MarkingFromInternalFields(JSObject host); 62 63 static void SetForThread(MarkingBarrier*); 64 static void ClearForThread(MarkingBarrier*); 65 66 static MarkingBarrier* CurrentMarkingBarrier(Heap* heap); 67 68 #ifdef ENABLE_SLOW_DCHECKS 69 template <typename T> 70 static inline bool IsRequired(HeapObject host, T value); 71 static bool IsImmortalImmovableHeapObject(HeapObject object); 72 #endif 73 74 private: 75 static inline base::Optional<Heap*> GetHeapIfMarking(HeapObject object); 76 77 static void MarkingSlow(Heap* heap, HeapObject host, HeapObjectSlot, 78 HeapObject value); 79 static void MarkingSlow(Heap* heap, Code host, RelocInfo*, HeapObject value); 80 static void MarkingSlow(Heap* heap, JSArrayBuffer host, 81 ArrayBufferExtension*); 82 static void MarkingSlow(Heap* heap, DescriptorArray, 83 int number_of_own_descriptors); 84 static void MarkingSlowFromGlobalHandle(Heap* heap, HeapObject value); 85 static void MarkingSlowFromInternalFields(Heap* heap, JSObject host); 86 }; 87 88 } // namespace internal 89 } // namespace v8 90 91 #endif // V8_HEAP_HEAP_WRITE_BARRIER_H_ 92