The DFG should be able to tier-up and OSR enter into the FTL
[WebKit-https.git] / Source / JavaScriptCore / interpreter / Register.h
1 /*
2  * Copyright (C) 2008, 2009 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 Computer, 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 Register_h
30 #define Register_h
31
32 #include "JSCJSValue.h"
33 #include <wtf/Assertions.h>
34 #include <wtf/VectorTraits.h>
35
36 namespace JSC {
37
38     class CodeBlock;
39     class ExecState;
40     class JSActivation;
41     class JSObject;
42     class JSPropertyNameIterator;
43     class JSScope;
44
45     struct InlineCallFrame;
46     struct Instruction;
47
48     typedef ExecState CallFrame;
49
50     class Register {
51         WTF_MAKE_FAST_ALLOCATED;
52     public:
53         Register();
54
55         Register(const JSValue&);
56         Register& operator=(const JSValue&);
57         JSValue jsValue() const;
58         EncodedJSValue encodedJSValue() const;
59         
60         Register& operator=(CallFrame*);
61         Register& operator=(CodeBlock*);
62         Register& operator=(JSScope*);
63         Register& operator=(Instruction*);
64         Register& operator=(InlineCallFrame*);
65
66         int32_t i() const;
67         JSActivation* activation() const;
68         CallFrame* callFrame() const;
69         CodeBlock* codeBlock() const;
70         JSObject* function() const;
71         JSPropertyNameIterator* propertyNameIterator() const;
72         JSScope* scope() const;
73         Instruction* vPC() const;
74         InlineCallFrame* asInlineCallFrame() const;
75         int32_t unboxedInt32() const;
76         bool unboxedBoolean() const;
77         double unboxedDouble() const;
78         JSCell* unboxedCell() const;
79         int32_t payload() const;
80         int32_t tag() const;
81         int32_t& payload();
82         int32_t& tag();
83
84         static Register withInt(int32_t i)
85         {
86             Register r = jsNumber(i);
87             return r;
88         }
89
90         static Register withCallee(JSObject* callee);
91
92     private:
93         union {
94             EncodedJSValue value;
95             CallFrame* callFrame;
96             CodeBlock* codeBlock;
97             Instruction* vPC;
98             InlineCallFrame* inlineCallFrame;
99             EncodedValueDescriptor encodedValue;
100             double number;
101         } u;
102     };
103
104     ALWAYS_INLINE Register::Register()
105     {
106 #ifndef NDEBUG
107         *this = JSValue();
108 #endif
109     }
110
111     ALWAYS_INLINE Register::Register(const JSValue& v)
112     {
113         u.value = JSValue::encode(v);
114     }
115
116     ALWAYS_INLINE Register& Register::operator=(const JSValue& v)
117     {
118         u.value = JSValue::encode(v);
119         return *this;
120     }
121
122     ALWAYS_INLINE JSValue Register::jsValue() const
123     {
124         return JSValue::decode(u.value);
125     }
126
127     ALWAYS_INLINE EncodedJSValue Register::encodedJSValue() const
128     {
129         return u.value;
130     }
131
132     // Interpreter functions
133
134     ALWAYS_INLINE Register& Register::operator=(CallFrame* callFrame)
135     {
136         u.callFrame = callFrame;
137         return *this;
138     }
139
140     ALWAYS_INLINE Register& Register::operator=(CodeBlock* codeBlock)
141     {
142         u.codeBlock = codeBlock;
143         return *this;
144     }
145
146     ALWAYS_INLINE Register& Register::operator=(Instruction* vPC)
147     {
148         u.vPC = vPC;
149         return *this;
150     }
151
152     ALWAYS_INLINE Register& Register::operator=(InlineCallFrame* inlineCallFrame)
153     {
154         u.inlineCallFrame = inlineCallFrame;
155         return *this;
156     }
157
158     ALWAYS_INLINE int32_t Register::i() const
159     {
160         return jsValue().asInt32();
161     }
162
163     ALWAYS_INLINE CallFrame* Register::callFrame() const
164     {
165         return u.callFrame;
166     }
167     
168     ALWAYS_INLINE CodeBlock* Register::codeBlock() const
169     {
170         return u.codeBlock;
171     }
172
173     ALWAYS_INLINE Instruction* Register::vPC() const
174     {
175         return u.vPC;
176     }
177
178     ALWAYS_INLINE InlineCallFrame* Register::asInlineCallFrame() const
179     {
180         return u.inlineCallFrame;
181     }
182         
183     ALWAYS_INLINE int32_t Register::unboxedInt32() const
184     {
185         return payload();
186     }
187
188     ALWAYS_INLINE bool Register::unboxedBoolean() const
189     {
190         return !!payload();
191     }
192
193     ALWAYS_INLINE double Register::unboxedDouble() const
194     {
195         return u.number;
196     }
197
198     ALWAYS_INLINE JSCell* Register::unboxedCell() const
199     {
200 #if USE(JSVALUE64)
201         return u.encodedValue.ptr;
202 #else
203         return bitwise_cast<JSCell*>(payload());
204 #endif
205     }
206
207     ALWAYS_INLINE int32_t Register::payload() const
208     {
209         return u.encodedValue.asBits.payload;
210     }
211
212     ALWAYS_INLINE int32_t Register::tag() const
213     {
214         return u.encodedValue.asBits.tag;
215     }
216
217     ALWAYS_INLINE int32_t& Register::payload()
218     {
219         return u.encodedValue.asBits.payload;
220     }
221
222     ALWAYS_INLINE int32_t& Register::tag()
223     {
224         return u.encodedValue.asBits.tag;
225     }
226
227 } // namespace JSC
228
229 namespace WTF {
230
231     template<> struct VectorTraits<JSC::Register> : VectorTraitsBase<true, JSC::Register> { };
232
233 } // namespace WTF
234
235 #endif // Register_h