Removed some public data and casting from the Heap
[WebKit-https.git] / Source / JavaScriptCore / heap / CopiedSpaceInlineMethods.h
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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef CopiedSpaceInlineMethods_h
27 #define CopiedSpaceInlineMethods_h
28
29 #include "CopiedBlock.h"
30 #include "CopiedSpace.h"
31 #include "Heap.h"
32 #include "HeapBlock.h"
33 #include "JSGlobalData.h"
34 #include <wtf/CheckedBoolean.h>
35
36 namespace JSC {
37
38 inline bool CopiedSpace::contains(CopiedBlock* block)
39 {
40     return !m_blockFilter.ruleOut(reinterpret_cast<Bits>(block)) && m_blockSet.contains(block);
41 }
42
43 inline bool CopiedSpace::contains(void* ptr, CopiedBlock*& result)
44 {
45     CopiedBlock* block = blockFor(ptr);
46     if (contains(block)) {
47         result = block;
48         return true;
49     }
50     block = oversizeBlockFor(ptr);
51     result = block;
52     return contains(block);
53 }
54
55 inline void CopiedSpace::pin(CopiedBlock* block)
56 {
57     block->m_isPinned = true;
58 }
59
60 inline void CopiedSpace::pinIfNecessary(void* opaquePointer)
61 {
62     // Pointers into the copied space come in the following varieties:
63     // 1)  Pointers to the start of a span of memory. This is the most
64     //     natural though not necessarily the most common.
65     // 2)  Pointers to one value-sized (8 byte) word past the end of
66     //     a span of memory. This currently occurs with semi-butterflies
67     //     and should be fixed soon, once the other half of the
68     //     butterfly lands.
69     // 3)  Pointers to the innards arising from loop induction variable
70     //     optimizations (either manual ones or automatic, by the
71     //     compiler).
72     // 4)  Pointers to the end of a span of memory in arising from
73     //     induction variable optimizations combined with the
74     //     GC-to-compiler contract laid out in the C spec: a pointer to
75     //     the end of a span of memory must be considered to be a
76     //     pointer to that memory.
77     
78     EncodedJSValue* pointer = reinterpret_cast<EncodedJSValue*>(opaquePointer);
79     CopiedBlock* block;
80
81     // Handle (1) and (3).
82     if (contains(pointer, block))
83         pin(block);
84     
85     // Handle (4). We don't have to explicitly check and pin the block under this
86     // pointer because it cannot possibly point to something that cases (1) and
87     // (3) above or case (2) below wouldn't already catch.
88     pointer--;
89     
90     // Handle (2)
91     pointer--;
92     if (contains(pointer, block))
93         pin(block);
94 }
95
96 inline void CopiedSpace::startedCopying()
97 {
98     std::swap(m_fromSpace, m_toSpace);
99
100     m_blockFilter.reset();
101     m_allocator.resetCurrentBlock();
102
103     ASSERT(!m_inCopyingPhase);
104     ASSERT(!m_numberOfLoanedBlocks);
105     m_inCopyingPhase = true;
106 }
107
108 inline void CopiedSpace::recycleBlock(CopiedBlock* block)
109 {
110     m_heap->blockAllocator().deallocate(CopiedBlock::destroy(block));
111
112     {
113         MutexLocker locker(m_loanedBlocksLock);
114         ASSERT(m_numberOfLoanedBlocks > 0);
115         m_numberOfLoanedBlocks--;
116         if (!m_numberOfLoanedBlocks)
117             m_loanedBlocksCondition.signal();
118     }
119 }
120
121 inline CopiedBlock* CopiedSpace::allocateBlockForCopyingPhase()
122 {
123     ASSERT(m_inCopyingPhase);
124     CopiedBlock* block = CopiedBlock::createNoZeroFill(m_heap->blockAllocator().allocate());
125
126     {
127         MutexLocker locker(m_loanedBlocksLock);
128         m_numberOfLoanedBlocks++;
129     }
130
131     ASSERT(!block->dataSize());
132     return block;
133 }
134
135 inline void CopiedSpace::allocateBlock()
136 {
137     if (m_heap->shouldCollect())
138         m_heap->collect(Heap::DoNotSweep);
139
140     m_allocator.resetCurrentBlock();
141     
142     CopiedBlock* block = CopiedBlock::create(m_heap->blockAllocator().allocate());
143         
144     m_toSpace->push(block);
145     m_blockFilter.add(reinterpret_cast<Bits>(block));
146     m_blockSet.add(block);
147     m_allocator.setCurrentBlock(block);
148 }
149
150 inline CheckedBoolean CopiedSpace::tryAllocate(size_t bytes, void** outPtr)
151 {
152     ASSERT(!m_heap->globalData()->isInitializingObject());
153
154     if (isOversize(bytes) || !m_allocator.tryAllocate(bytes, outPtr))
155         return tryAllocateSlowCase(bytes, outPtr);
156     
157     ASSERT(*outPtr);
158     return true;
159 }
160
161 inline bool CopiedSpace::isOversize(size_t bytes)
162 {
163     return bytes > s_maxAllocationSize;
164 }
165
166 inline bool CopiedSpace::isPinned(void* ptr)
167 {
168     return blockFor(ptr)->m_isPinned;
169 }
170
171 inline CopiedBlock* CopiedSpace::oversizeBlockFor(void* ptr)
172 {
173     return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & WTF::pageMask());
174 }
175
176 inline CopiedBlock* CopiedSpace::blockFor(void* ptr)
177 {
178     return reinterpret_cast<CopiedBlock*>(reinterpret_cast<size_t>(ptr) & s_blockMask);
179 }
180
181 } // namespace JSC
182
183 #endif