Lines Matching full:heap
44 // Heap structures:
46 // A JS heap consists of a young generation, an old generation, and a large
66 // buffer overflow) iterate intergenerational pointers without decoding heap
70 // the Heap::InNewSpace() predicate must be a pointer to a live heap object in
301 // any heap object.
310 static inline MemoryChunk* FromAnyPointerAddress(Heap* heap, Address addr);
623 inline Heap* heap() { return heap_; }
689 Heap* heap_;
714 static MemoryChunk* Initialize(Heap* heap,
803 static inline Page* Initialize(Heap* heap,
860 static inline LargePage* Initialize(Heap* heap, MemoryChunk* chunk);
871 Space(Heap* heap, AllocationSpace id, Executability executable)
872 : heap_(heap), id_(id), executable_(executable) {}
876 Heap* heap() const { return heap_; }
904 Heap* heap_;
911 // All heap objects containing executable code (code objects) must be allocated
923 // Can only be called once, at heap initialization time.
1049 // allocator allocated and deallocates pages for the paged heap spaces and large
1187 // of determining that pointers are outside the heap. The estimate is
1189 // to our heap. The range is [lowest, highest[, inclusive on the low end
1226 // Interface for heap object iterator to be implemented by all object space
1242 // Heap object iterator in new/old/map spaces.
1471 // Free-list nodes are free blocks in the heap. They look like heap objects
1472 // (free-list node pointers have the heap object tag, and they have a map like
1473 // a heap object). They have a size and a next pointer. The next pointer is
1488 // looks like a heap object to the garbage collector and heap iteration
1490 void set_size(Heap* heap, int size_in_bytes);
1531 void RepairFreeList(Heap* heap);
1621 void RepairLists(Heap* heap);
1638 Heap* heap_;
1659 PagedSpace(Heap* heap,
1803 // skipped when scanning the heap.
1942 // it cannot allocate requested number of pages from OS, or if the hard heap
2070 static NewSpacePage* Initialize(Heap* heap,
2094 SemiSpace(Heap* heap, SemiSpaceId semispace)
2095 : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
2105 // Tear down the space. Heap memory was not allocated by the space, so it
2164 // True if the object is a heap object in the address range of this
2259 // semispace of the heap's new space. It iterates over the objects in the
2350 explicit NewSpace(Heap* heap)
2351 : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
2352 to_space_(heap, kToSpace),
2353 from_space_(heap, kFromSpace),
2360 // Tears down the space. Heap memory was not allocated by the space, so it
2522 // True if the object is a heap object in the address range of the
2551 // Record the allocation or promotion of a heap object. Note that we don't
2624 OldSpace(Heap* heap,
2628 : PagedSpace(heap, max_capacity, id, executable) {
2650 MapSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
2651 : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
2691 CellSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id)
2692 : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {
2717 PropertyCellSpace(Heap* heap, intptr_t max_capacity,
2719 : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE) {
2740 // the large object space. A large object is allocated from OS heap with
2747 LargeObjectSpace(Heap* heap, intptr_t max_capacity, AllocationSpace id);
2804 // Checks whether a heap object is in this space; O(1).
2863 inline explicit PointerChunkIterator(Heap* heap);
