2011-01-27 Oliver Hunt <oliver@apple.com>
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSFunction.cpp
1 /*
2  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
5  *  Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
6  *  Copyright (C) 2007 Maks Orlovich
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Library General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Library General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Library General Public License
19  *  along with this library; see the file COPYING.LIB.  If not, write to
20  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  *  Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "JSFunction.h"
27
28 #include "CodeBlock.h"
29 #include "CommonIdentifiers.h"
30 #include "CallFrame.h"
31 #include "ExceptionHelpers.h"
32 #include "FunctionPrototype.h"
33 #include "JSGlobalObject.h"
34 #include "JSNotAnObject.h"
35 #include "Interpreter.h"
36 #include "ObjectPrototype.h"
37 #include "Parser.h"
38 #include "PropertyNameArray.h"
39 #include "ScopeChainMark.h"
40
41 using namespace WTF;
42 using namespace Unicode;
43
44 namespace JSC {
45 #if ENABLE(JIT)
46 EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState* exec)
47 {
48     return throwVMError(exec, createNotAConstructorError(exec, exec->callee()));
49 }
50 #endif
51
52 ASSERT_CLASS_FITS_IN_CELL(JSFunction);
53
54 const ClassInfo JSFunction::info = { "Function", 0, 0, 0 };
55
56 bool JSFunction::isHostFunctionNonInline() const
57 {
58     return isHostFunction();
59 }
60
61 JSFunction::JSFunction(NonNullPassRefPtr<Structure> structure)
62     : Base(structure)
63     , m_executable(adoptRef(new VPtrHackExecutable()))
64     , m_scopeChain(NoScopeChain())
65 {
66 }
67
68 #if ENABLE(JIT)
69 JSFunction::JSFunction(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, int length, const Identifier& name, PassRefPtr<NativeExecutable> thunk)
70     : Base(globalObject, structure)
71     , m_executable(thunk)
72     , m_scopeChain(globalObject->globalScopeChain())
73 {
74     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
75     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(length), DontDelete | ReadOnly | DontEnum);
76 }
77 #endif
78
79 JSFunction::JSFunction(ExecState* exec, JSGlobalObject* globalObject, NonNullPassRefPtr<Structure> structure, int length, const Identifier& name, NativeFunction func)
80     : Base(globalObject, structure)
81 #if ENABLE(JIT)
82     , m_executable(exec->globalData().getHostFunction(func))
83 #endif
84     , m_scopeChain(globalObject->globalScopeChain())
85 {
86     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
87 #if ENABLE(JIT)
88     putDirect(exec->globalData(), exec->propertyNames().length, jsNumber(length), DontDelete | ReadOnly | DontEnum);
89 #else
90     UNUSED_PARAM(length);
91     UNUSED_PARAM(func);
92     ASSERT_NOT_REACHED();
93 #endif
94 }
95
96 JSFunction::JSFunction(ExecState* exec, NonNullPassRefPtr<FunctionExecutable> executable, ScopeChainNode* scopeChainNode)
97     : Base(scopeChainNode->globalObject, scopeChainNode->globalObject->functionStructure())
98     , m_executable(executable)
99     , m_scopeChain(scopeChainNode)
100 {
101     const Identifier& name = static_cast<FunctionExecutable*>(m_executable.get())->name();
102     putDirect(exec->globalData(), exec->globalData().propertyNames->name, jsString(exec, name.isNull() ? "" : name.ustring()), DontDelete | ReadOnly | DontEnum);
103 }
104
105 JSFunction::~JSFunction()
106 {
107     ASSERT(vptr() == JSGlobalData::jsFunctionVPtr);
108
109     // JIT code for other functions may have had calls linked directly to the code for this function; these links
110     // are based on a check for the this pointer value for this JSFunction - which will no longer be valid once
111     // this memory is freed and may be reused (potentially for another, different JSFunction).
112     if (!isHostFunction()) {
113 #if ENABLE(JIT_OPTIMIZE_CALL)
114         ASSERT(m_executable);
115         if (jsExecutable()->isGeneratedForCall())
116             jsExecutable()->generatedBytecodeForCall().unlinkCallers();
117         if (jsExecutable()->isGeneratedForConstruct())
118             jsExecutable()->generatedBytecodeForConstruct().unlinkCallers();
119 #endif
120     }
121 }
122
123 static const char* StrictModeCallerAccessError = "Cannot access caller property of a strict mode function";
124 static const char* StrictModeArgumentsAccessError = "Cannot access arguments property of a strict mode function";
125
126 static void createDescriptorForThrowingProperty(ExecState* exec, PropertyDescriptor& descriptor, const char* message)
127 {
128     JSValue thrower = createTypeErrorFunction(exec, message);
129     descriptor.setAccessorDescriptor(thrower, thrower, DontEnum | DontDelete | Getter | Setter);
130 }
131
132 const UString& JSFunction::name(ExecState* exec)
133 {
134     return asString(getDirect(exec->globalData().propertyNames->name))->tryGetValue();
135 }
136
137 const UString JSFunction::displayName(ExecState* exec)
138 {
139     JSValue displayName = getDirect(exec->globalData().propertyNames->displayName);
140     
141     if (displayName && isJSString(&exec->globalData(), displayName))
142         return asString(displayName)->tryGetValue();
143     
144     return UString();
145 }
146
147 const UString JSFunction::calculatedDisplayName(ExecState* exec)
148 {
149     const UString explicitName = displayName(exec);
150     
151     if (!explicitName.isEmpty())
152         return explicitName;
153     
154     return name(exec);
155 }
156
157 void JSFunction::markChildren(MarkStack& markStack)
158 {
159     Base::markChildren(markStack);
160     if (!isHostFunction()) {
161         jsExecutable()->markAggregate(markStack);
162         scope().markAggregate(markStack);
163     }
164 }
165
166 CallType JSFunction::getCallData(CallData& callData)
167 {
168 #if ENABLE(JIT)
169     if (isHostFunction()) {
170         callData.native.function = nativeFunction();
171         return CallTypeHost;
172     }
173 #endif
174     callData.js.functionExecutable = jsExecutable();
175     callData.js.scopeChain = scope().node();
176     return CallTypeJS;
177 }
178
179 JSValue JSFunction::argumentsGetter(ExecState* exec, JSValue slotBase, const Identifier&)
180 {
181     JSFunction* thisObj = asFunction(slotBase);
182     ASSERT(!thisObj->isHostFunction());
183     return exec->interpreter()->retrieveArguments(exec, thisObj);
184 }
185
186 JSValue JSFunction::callerGetter(ExecState* exec, JSValue slotBase, const Identifier&)
187 {
188     JSFunction* thisObj = asFunction(slotBase);
189     ASSERT(!thisObj->isHostFunction());
190     return exec->interpreter()->retrieveCaller(exec, thisObj);
191 }
192
193 JSValue JSFunction::lengthGetter(ExecState*, JSValue slotBase, const Identifier&)
194 {
195     JSFunction* thisObj = asFunction(slotBase);
196     ASSERT(!thisObj->isHostFunction());
197     return jsNumber(thisObj->jsExecutable()->parameterCount());
198 }
199
200 bool JSFunction::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
201 {
202     if (isHostFunction())
203         return Base::getOwnPropertySlot(exec, propertyName, slot);
204
205     if (propertyName == exec->propertyNames().prototype) {
206         JSValue* location = getDirectLocation(propertyName);
207
208         if (!location) {
209             JSObject* prototype = new (exec) JSObject(scope().globalObject()->emptyObjectStructure());
210             prototype->putDirect(exec->globalData(), exec->propertyNames().constructor, this, DontEnum);
211             putDirect(exec->globalData(), exec->propertyNames().prototype, prototype, DontDelete | DontEnum);
212             location = getDirectLocation(propertyName);
213         }
214
215         slot.setValueSlot(this, location, offsetForLocation(location));
216     }
217
218     if (propertyName == exec->propertyNames().arguments) {
219         if (jsExecutable()->isStrictMode()) {
220             throwTypeError(exec, "Can't access arguments object of a strict mode function");
221             slot.setValue(jsNull());
222             return true;
223         }
224    
225         slot.setCacheableCustom(this, argumentsGetter);
226         return true;
227     }
228
229     if (propertyName == exec->propertyNames().length) {
230         slot.setCacheableCustom(this, lengthGetter);
231         return true;
232     }
233
234     if (propertyName == exec->propertyNames().caller) {
235         if (jsExecutable()->isStrictMode()) {
236             throwTypeError(exec, StrictModeCallerAccessError);
237             slot.setValue(jsNull());
238             return true;
239         }
240         slot.setCacheableCustom(this, callerGetter);
241         return true;
242     }
243
244     return Base::getOwnPropertySlot(exec, propertyName, slot);
245 }
246
247 bool JSFunction::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
248 {
249     if (isHostFunction())
250         return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
251     
252     if (propertyName == exec->propertyNames().prototype) {
253         PropertySlot slot;
254         getOwnPropertySlot(exec, propertyName, slot);
255         return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
256     }
257     
258     if (propertyName == exec->propertyNames().arguments) {
259         if (jsExecutable()->isStrictMode())
260             createDescriptorForThrowingProperty(exec, descriptor, StrictModeArgumentsAccessError);
261         else
262             descriptor.setDescriptor(exec->interpreter()->retrieveArguments(exec, this), ReadOnly | DontEnum | DontDelete);
263         return true;
264     }
265     
266     if (propertyName == exec->propertyNames().length) {
267         descriptor.setDescriptor(jsNumber(jsExecutable()->parameterCount()), ReadOnly | DontEnum | DontDelete);
268         return true;
269     }
270     
271     if (propertyName == exec->propertyNames().caller) {
272         if (jsExecutable()->isStrictMode())
273             createDescriptorForThrowingProperty(exec, descriptor, StrictModeCallerAccessError);
274         else
275             descriptor.setDescriptor(exec->interpreter()->retrieveCaller(exec, this), ReadOnly | DontEnum | DontDelete);
276         return true;
277     }
278     
279     return Base::getOwnPropertyDescriptor(exec, propertyName, descriptor);
280 }
281
282 void JSFunction::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)
283 {
284     if (!isHostFunction() && (mode == IncludeDontEnumProperties)) {
285         // Make sure prototype has been reified.
286         PropertySlot slot;
287         getOwnPropertySlot(exec, exec->propertyNames().prototype, slot);
288
289         propertyNames.add(exec->propertyNames().arguments);
290         propertyNames.add(exec->propertyNames().callee);
291         propertyNames.add(exec->propertyNames().caller);
292         propertyNames.add(exec->propertyNames().length);
293     }
294     Base::getOwnPropertyNames(exec, propertyNames, mode);
295 }
296
297 void JSFunction::put(ExecState* exec, const Identifier& propertyName, JSValue value, PutPropertySlot& slot)
298 {
299     if (isHostFunction()) {
300         Base::put(exec, propertyName, value, slot);
301         return;
302     }
303     if (propertyName == exec->propertyNames().prototype) {
304         // Make sure prototype has been reified, such that it can only be overwritten
305         // following the rules set out in ECMA-262 8.12.9.
306         PropertySlot slot;
307         getOwnPropertySlot(exec, propertyName, slot);
308     }
309     if (jsExecutable()->isStrictMode()) {
310         if (propertyName == exec->propertyNames().arguments) {
311             throwTypeError(exec, StrictModeArgumentsAccessError);
312             return;
313         }
314         if (propertyName == exec->propertyNames().caller) {
315             throwTypeError(exec, StrictModeCallerAccessError);
316             return;
317         }
318     }
319     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
320         return;
321     Base::put(exec, propertyName, value, slot);
322 }
323
324 bool JSFunction::deleteProperty(ExecState* exec, const Identifier& propertyName)
325 {
326     if (isHostFunction())
327         return Base::deleteProperty(exec, propertyName);
328     if (propertyName == exec->propertyNames().arguments || propertyName == exec->propertyNames().length)
329         return false;
330     return Base::deleteProperty(exec, propertyName);
331 }
332
333 // ECMA 13.2.2 [[Construct]]
334 ConstructType JSFunction::getConstructData(ConstructData& constructData)
335 {
336     if (isHostFunction())
337         return ConstructTypeNone;
338     constructData.js.functionExecutable = jsExecutable();
339     constructData.js.scopeChain = scope().node();
340     return ConstructTypeJS;
341 }
342
343 } // namespace JSC