Add finalizer to JSObject
[WebKit-https.git] / Source / JavaScriptCore / heap / MarkedBlock.cpp
1 /*
2  * Copyright (C) 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "MarkedBlock.h"
28
29 #include "JSCell.h"
30 #include "JSObject.h"
31 #include "ScopeChain.h"
32
33 namespace JSC {
34
35 MarkedBlock* MarkedBlock::create(Heap* heap, size_t cellSize)
36 {
37     PageAllocationAligned allocation = PageAllocationAligned::allocate(blockSize, blockSize, OSAllocator::JSGCHeapPages);
38     if (!static_cast<bool>(allocation))
39         CRASH();
40     return new (allocation.base()) MarkedBlock(allocation, heap, cellSize);
41 }
42
43 MarkedBlock* MarkedBlock::recycle(MarkedBlock* block, size_t cellSize)
44 {
45     return new (block) MarkedBlock(block->m_allocation, block->m_heap, cellSize);
46 }
47
48 void MarkedBlock::destroy(MarkedBlock* block)
49 {
50     block->m_allocation.deallocate();
51 }
52
53 MarkedBlock::MarkedBlock(const PageAllocationAligned& allocation, Heap* heap, size_t cellSize)
54     : m_atomsPerCell((cellSize + atomSize - 1) / atomSize)
55     , m_endAtom(atomsPerBlock - m_atomsPerCell + 1)
56     , m_state(New) // All cells start out unmarked.
57     , m_allocation(allocation)
58     , m_heap(heap)
59 {
60     HEAP_LOG_BLOCK_STATE_TRANSITION(this);
61 }
62
63 inline void MarkedBlock::callDestructor(JSCell* cell, void* jsFinalObjectVPtr)
64 {
65     // A previous eager sweep may already have run cell's destructor.
66     if (cell->isZapped())
67         return;
68
69     void* vptr = cell->vptr();
70 #if ENABLE(SIMPLE_HEAP_PROFILING)
71     m_heap->m_destroyedTypeCounts.countVPtr(vptr);
72 #endif
73     if (vptr != jsFinalObjectVPtr)
74         cell->~JSCell();
75
76     cell->zap();
77 }
78
79 template<MarkedBlock::BlockState blockState, MarkedBlock::SweepMode sweepMode>
80 MarkedBlock::FreeCell* MarkedBlock::specializedSweep()
81 {
82     ASSERT(blockState != Allocated && blockState != FreeListed);
83
84     // This produces a free list that is ordered in reverse through the block.
85     // This is fine, since the allocation code makes no assumptions about the
86     // order of the free list.
87     FreeCell* head = 0;
88     void* jsFinalObjectVPtr = m_heap->globalData()->jsFinalObjectVPtr;
89     for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell) {
90         if (blockState == Marked && m_marks.get(i))
91             continue;
92
93         JSCell* cell = reinterpret_cast<JSCell*>(&atoms()[i]);
94         if (blockState == Zapped && !cell->isZapped())
95             continue;
96
97         if (blockState != New)
98             callDestructor(cell, jsFinalObjectVPtr);
99
100         if (sweepMode == SweepToFreeList) {
101             FreeCell* freeCell = reinterpret_cast<FreeCell*>(cell);
102             freeCell->next = head;
103             head = freeCell;
104         }
105     }
106
107     m_state = ((sweepMode == SweepToFreeList) ? FreeListed : Zapped);
108     return head;
109 }
110
111 MarkedBlock::FreeCell* MarkedBlock::sweep(SweepMode sweepMode)
112 {
113     HEAP_LOG_BLOCK_STATE_TRANSITION(this);
114
115     switch (m_state) {
116     case New:
117         ASSERT(sweepMode == SweepToFreeList);
118         return specializedSweep<New, SweepToFreeList>();
119     case FreeListed:
120         // Happens when a block transitions to fully allocated.
121         ASSERT(sweepMode == SweepToFreeList);
122         return 0;
123     case Allocated:
124         ASSERT_NOT_REACHED();
125         return 0;
126     case Marked:
127         return sweepMode == SweepToFreeList
128             ? specializedSweep<Marked, SweepToFreeList>()
129             : specializedSweep<Marked, SweepOnly>();
130     case Zapped:
131         return sweepMode == SweepToFreeList
132             ? specializedSweep<Zapped, SweepToFreeList>()
133             : specializedSweep<Zapped, SweepOnly>();
134     }
135
136     ASSERT_NOT_REACHED();
137     return 0;
138 }
139
140 void MarkedBlock::zapFreeList(FreeCell* firstFreeCell)
141 {
142     HEAP_LOG_BLOCK_STATE_TRANSITION(this);
143
144     // Roll back to a coherent state for Heap introspection. Cells newly
145     // allocated from our free list are not currently marked, so we need another
146     // way to tell what's live vs dead. We use zapping for that.
147
148     FreeCell* next;
149     for (FreeCell* current = firstFreeCell; current; current = next) {
150         next = current->next;
151         reinterpret_cast<JSCell*>(current)->zap();
152     }
153
154     m_state = Zapped;
155 }
156
157 } // namespace JSC