401fbc0c55abf7ca11d4b014d6c2c1a732bbc818
[WebKit-https.git] / Source / JavaScriptCore / interpreter / JSStack.h
1 /*
2  * Copyright (C) 2008, 2009, 2013, 2014 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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #ifndef JSStack_h
30 #define JSStack_h
31
32 #include "ExecutableAllocator.h"
33 #include "Register.h"
34 #include <wtf/Noncopyable.h>
35 #include <wtf/PageReservation.h>
36 #include <wtf/VMTags.h>
37
38 namespace JSC {
39
40     class CodeBlockSet;
41     class ConservativeRoots;
42     class ExecState;
43     class JITStubRoutineSet;
44     class VM;
45     class LLIntOffsetsExtractor;
46
47     struct Instruction;
48     typedef ExecState CallFrame;
49
50     struct CallerFrameAndPC {
51         CallFrame* callerFrame;
52         Instruction* pc;
53     };
54
55     class JSStack {
56         WTF_MAKE_NONCOPYABLE(JSStack);
57     public:
58         enum CallFrameHeaderEntry {
59             CallerFrameAndPCSize = sizeof(CallerFrameAndPC) / sizeof(Register),
60             CodeBlock = CallerFrameAndPCSize,
61             Callee,
62             ArgumentCount,
63             CallFrameHeaderSize,
64
65             // The following entries are not part of the CallFrameHeader but are provided here as a convenience:
66             ThisArgument = CallFrameHeaderSize,
67             FirstArgument,
68         };
69
70         static const size_t commitSize = 16 * 1024;
71         // Allow 8k of excess registers before we start trying to reap the stack
72         static const ptrdiff_t maxExcessCapacity = 8 * 1024;
73
74         JSStack(VM&);
75         
76         bool ensureCapacityFor(Register* newTopOfStack);
77
78         bool containsAddress(Register* address) { return (lowAddress() <= address && address < highAddress()); }
79         static size_t committedByteCount();
80
81 #if ENABLE(JIT)
82         void gatherConservativeRoots(ConservativeRoots&) { }
83         void gatherConservativeRoots(ConservativeRoots&, JITStubRoutineSet&, CodeBlockSet&) { }
84         void sanitizeStack() { }
85         static void initializeThreading() { }
86 #else
87         ~JSStack();
88
89         void gatherConservativeRoots(ConservativeRoots&);
90         void gatherConservativeRoots(ConservativeRoots&, JITStubRoutineSet&, CodeBlockSet&);
91         void sanitizeStack();
92
93         Register* baseOfStack() const
94         {
95             return highAddress() - 1;
96         }
97
98         size_t size() const { return highAddress() - lowAddress(); }
99
100         static void initializeThreading();
101
102         void setReservedZoneSize(size_t);
103
104         inline Register* topOfStack();
105 #endif // ENABLE(JIT)
106
107     private:
108
109 #if !ENABLE(JIT)
110         Register* lowAddress() const
111         {
112             return m_end + 1;
113         }
114
115         Register* highAddress() const
116         {
117             return reinterpret_cast_ptr<Register*>(static_cast<char*>(m_reservation.base()) + m_reservation.size());
118         }
119 #else
120         Register* lowAddress() const;
121         Register* highAddress() const;
122 #endif // !ENABLE(JIT)
123
124 #if !ENABLE(JIT)
125         inline Register* topOfFrameFor(CallFrame*);
126
127         Register* reservationTop() const
128         {
129             char* reservationTop = static_cast<char*>(m_reservation.base());
130             return reinterpret_cast_ptr<Register*>(reservationTop);
131         }
132
133         bool grow(Register* newTopOfStack);
134         bool growSlowCase(Register* newTopOfStack);
135         void shrink(Register* newTopOfStack);
136         void releaseExcessCapacity();
137         void addToCommittedByteCount(long);
138
139         void setStackLimit(Register* newTopOfStack);
140 #endif // !ENABLE(JIT)
141
142         VM& m_vm;
143         CallFrame*& m_topCallFrame;
144 #if !ENABLE(JIT)
145         Register* m_end;
146         Register* m_commitTop;
147         PageReservation m_reservation;
148         Register* m_lastStackTop;
149         ptrdiff_t m_reservedZoneSizeInRegisters;
150 #endif // !ENABLE(JIT)
151
152         friend class LLIntOffsetsExtractor;
153     };
154
155 } // namespace JSC
156
157 #endif // JSStack_h