Removed some public data and casting from the Heap
[WebKit-https.git] / Source / JavaScriptCore / heap / CopiedBlock.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 CopiedBlock_h
27 #define CopiedBlock_h
28
29 #include "HeapBlock.h"
30 #include "JSValue.h"
31 #include "JSValueInlineMethods.h"
32
33 namespace JSC {
34
35 class CopiedSpace;
36
37 class CopiedBlock : public HeapBlock<CopiedBlock> {
38     friend class CopiedSpace;
39     friend class CopiedAllocator;
40 public:
41     static CopiedBlock* create(const PageAllocationAligned&);
42     static CopiedBlock* createNoZeroFill(const PageAllocationAligned&);
43
44     // The payload is the region of the block that is usable for allocations.
45     char* payload();
46     char* payloadEnd();
47     size_t payloadCapacity();
48     
49     // The data is the region of the block that has been used for allocations.
50     char* data();
51     char* dataEnd();
52     size_t dataSize();
53     
54     // The wilderness is the region of the block that is usable for allocations
55     // but has not been so used.
56     char* wilderness();
57     char* wildernessEnd();
58     size_t wildernessSize();
59     
60     size_t size();
61     size_t capacity();
62
63 private:
64     CopiedBlock(const PageAllocationAligned&);
65     void zeroFillWilderness(); // Can be called at any time to zero-fill to the end of the block.
66
67     size_t m_remaining;
68     uintptr_t m_isPinned;
69 };
70
71 inline CopiedBlock* CopiedBlock::createNoZeroFill(const PageAllocationAligned& allocation)
72 {
73     return new(NotNull, allocation.base()) CopiedBlock(allocation);
74 }
75
76 inline CopiedBlock* CopiedBlock::create(const PageAllocationAligned& allocation)
77 {
78     CopiedBlock* block = createNoZeroFill(allocation);
79     block->zeroFillWilderness();
80     return block;
81 }
82
83 inline void CopiedBlock::zeroFillWilderness()
84 {
85 #if USE(JSVALUE64)
86     memset(wilderness(), 0, wildernessSize());
87 #else
88     JSValue emptyValue;
89     JSValue* limit = reinterpret_cast_ptr<JSValue*>(wildernessEnd());
90     for (JSValue* currentValue = reinterpret_cast<JSValue*>(wilderness()); currentValue < limit; currentValue++)
91         *currentValue = emptyValue;
92 #endif
93 }
94
95 inline CopiedBlock::CopiedBlock(const PageAllocationAligned& allocation)
96     : HeapBlock<CopiedBlock>(allocation)
97     , m_remaining(payloadCapacity())
98     , m_isPinned(false)
99 {
100     ASSERT(is8ByteAligned(reinterpret_cast<void*>(m_remaining)));
101 }
102
103 inline char* CopiedBlock::payload()
104 {
105     return reinterpret_cast<char*>(this) + ((sizeof(CopiedBlock) + 7) & ~7);
106 }
107
108 inline char* CopiedBlock::payloadEnd()
109 {
110     return reinterpret_cast<char*>(this) + allocation().size();
111 }
112
113 inline size_t CopiedBlock::payloadCapacity()
114 {
115     return payloadEnd() - payload();
116 }
117
118 inline char* CopiedBlock::data()
119 {
120     return payload();
121 }
122
123 inline char* CopiedBlock::dataEnd()
124 {
125     return payloadEnd() - m_remaining;
126 }
127
128 inline size_t CopiedBlock::dataSize()
129 {
130     return dataEnd() - data();
131 }
132
133 inline char* CopiedBlock::wilderness()
134 {
135     return dataEnd();
136 }
137
138 inline char* CopiedBlock::wildernessEnd()
139 {
140     return payloadEnd();
141 }
142
143 inline size_t CopiedBlock::wildernessSize()
144 {
145     return wildernessEnd() - wilderness();
146 }
147
148 inline size_t CopiedBlock::size()
149 {
150     return dataSize();
151 }
152
153 inline size_t CopiedBlock::capacity()
154 {
155     return allocation().size();
156 }
157
158 } // namespace JSC
159
160 #endif