Lines Matching defs:object
35 #include "src/objects/heap-object.h"
318 // object references.
476 // of non-weak slots inside |object|.
478 V8_EXPORT_PRIVATE void WriteBarrierForRange(HeapObject object, TSlot start,
483 V8_EXPORT_PRIVATE static void GenerationalBarrierSlow(HeapObject object,
492 V8_EXPORT_PRIVATE static bool PageFlagsAreConsistent(HeapObject object);
522 // Initialize a filler object to keep the ability to iterate over the heap
533 void CreateFillerForArray(T object, int elements_to_trim, int bytes_to_trim);
535 bool CanMoveObjectStart(HeapObject object);
537 bool IsImmovable(HeapObject object);
539 V8_EXPORT_PRIVATE static bool IsLargeObject(HeapObject object);
541 // Trim the given array from the left. Note that this relocates the object
557 void set_native_contexts_list(Object object) {
558 native_contexts_list_.store(object.ptr(), std::memory_order_release);
565 void set_allocation_sites_list(Object object) {
566 allocation_sites_list_ = object;
570 void set_dirty_js_finalization_registries_list(Object object) {
571 dirty_js_finalization_registries_list_ = object;
576 void set_dirty_js_finalization_registries_list_tail(Object object) {
577 dirty_js_finalization_registries_list_tail_ = object;
596 // Checks whether the given object is allowed to be migrated from it's
598 bool AllowedToBeMigrated(Map map, HeapObject object, AllocationSpace dest);
631 HeapObject object, UnprotectMemoryOrigin origin);
662 // If an object has an AllocationMemento trailing it, return it, otherwise
665 inline AllocationMemento FindAllocationMemento(Map map, HeapObject object);
691 void AppendArrayBufferExtension(JSArrayBuffer object,
693 void DetachArrayBufferExtension(JSArrayBuffer object,
718 // An object should be promoted if the object has survived a
754 // This event is triggered after object is moved to a new place.
822 // Bootstraps the object heap with the core set of objects required to run.
935 std::function<void(HeapObject object, ObjectSlot slot, Object target)>
1049 void ClearRecordedSlot(HeapObject object, ObjectSlot slot);
1054 void VerifyClearedSlot(HeapObject object, ObjectSlot slot);
1092 // Ensures that sweeping is finished for that object's page.
1093 void EnsureSweepingCompleted(HeapObject object);
1109 // The runtime uses this function to notify potentially unsafe object layout
1111 // The old size is the size of the object before layout change.
1112 // By default recorded slots in the object are invalidated. Pass
1116 HeapObject object, const DisallowGarbageCollection&,
1124 V8_EXPORT_PRIVATE void VerifyObjectLayoutChange(HeapObject object,
1127 V8_EXPORT_PRIVATE void VerifySafeMapTransition(HeapObject object,
1140 // Invalidates references in the given {code} object that are referenced
1202 // Methods checking/returning the space of a given object/address. ===========
1205 // Returns whether the object resides in new space.
1206 static inline bool InYoungGeneration(Object object);
1207 static inline bool InYoungGeneration(MaybeObject object);
1209 static inline bool InFromPage(Object object);
1210 static inline bool InFromPage(MaybeObject object);
1212 static inline bool InToPage(Object object);
1213 static inline bool InToPage(MaybeObject object);
1216 // Returns whether the object resides in old space.
1217 inline bool InOldSpace(Object object);
1219 // Checks whether an address/object is in the non-read-only heap (including
1223 // Same as above, but checks whether the object resides in any of the code
1227 // Checks whether an address/object is in the non-read-only heap (including
1232 // Returns whether the object should be in the shared old space.
1235 // Checks whether an address/object in a space.
1252 // Returns the number of buckets used by object statistics tracking during a
1257 // Returns object statistics about count and size at the last major GC.
1263 // Retrieves names of buckets used by object statistics tracking.
1267 // The total number of native contexts object on the heap.
1339 // Heap doesn't guarantee that it can allocate an object that requires
1469 // Creates a filler object and returns a heap object immediately after it.
1470 V8_EXPORT_PRIVATE HeapObject PrecedeWithFiller(HeapObject object,
1473 // Creates a filler object if needed for alignment and returns a heap object
1474 // immediately after it. If any space is left after the returned object,
1475 // another filler object is created so the over allocated memory is iterable.
1477 AlignWithFiller(HeapObject object, int object_size, int allocation_size,
1495 // Updates the AllocationSite of a given {object}. The entry (including the
1498 Map map, HeapObject object, PretenuringFeedbackMap* pretenuring_feedback);
1525 // Check if the given object was recently allocated and its fields may appear
1528 inline bool IsPendingAllocation(HeapObject object);
1529 inline bool IsPendingAllocation(Object object);
1537 // Heap object allocation tracking. ==========================================
1552 // Adds the given object to the weak table of retaining path targets.
1553 // On each GC if the marker discovers the object, it will print the retaining
1555 void AddRetainingPathTarget(Handle<HeapObject> object,
1562 // Returns the Code object for a given interior pointer.
1569 // Casts a heap object to a code object and checks if the inner_pointer is
1570 // within the object.
1571 Code GcSafeCastToCode(HeapObject object, Address inner_pointer);
1573 // Returns the map of an object. Can be used during garbage collection, i.e.
1575 Map GcSafeMapOfCodeSpaceObject(HeapObject object);
1584 void VerifyRememberedSetFor(HeapObject object);
1628 static Isolate* GetIsolateFromWritableObject(HeapObject object);
1794 // Zaps the memory of a code object.
1798 // Initialize a filler object to keep the ability to iterate over the heap
1799 // when introducing gaps within pages. If the memory after the object header
1810 HeapObject object, TSlot start_slot,
1866 // Attempt to over-approximate the weak closure by marking object groups and
1882 // object in old space must not move.
2043 // Allocate an uninitialized object. The memory is non-executable if the
2067 // Allocates a heap object based on the map.
2083 inline bool IsPendingAllocationInternal(HeapObject object);
2089 void AddRetainer(HeapObject retainer, HeapObject object);
2090 void AddEphemeronRetainer(HeapObject retainer, HeapObject object);
2091 void AddRetainingRoot(Root root, HeapObject object);
2092 // Returns true if the given object is a target of retaining path tracking.
2093 // Stores the option corresponding to the object in the provided *option.
2094 bool IsRetainingPathTarget(HeapObject object, RetainingPathOption* option);
2095 void PrintRetainingPath(HeapObject object, RetainingPathOption option);
2246 // generation and on every allocation in large object space.
2314 // This object controls virtual space reserved for code on the V8 heap. This
2348 // they have been visited (values) by finding a memento behind an object. The
2415 // If an object is retained by an ephemeron, then the retaining key of the
2589 explicit inline CodePageMemoryModificationScope(Code object);
2597 // object would change the {MemoryChunk} that this scope targets.
2611 // or care about intergenerational references. All heap object pointers have to
2721 // Abstract base class for checking whether a weak object should be retained.
2726 // Return whether this object should be retained. If nullptr is returned the
2727 // object has no references. Otherwise the address of the retained object
2728 // should be returned as in some GC situations the object has been moved.
2729 virtual Object RetainAs(Object object) = 0;
2733 // Allows observation of heap object allocations.