Object.getOwnPropertyNames includes "arguments" and "caller" for bound functions
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSBoundFunction.cpp
1 /*
2  * Copyright (C) 2011, 2016-2017 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 #include "config.h"
27 #include "JSBoundFunction.h"
28
29 #include "GetterSetter.h"
30 #include "JSGlobalObject.h"
31 #include "JSCInlines.h"
32
33 namespace JSC {
34
35 const ClassInfo JSBoundFunction::s_info = { "Function", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBoundFunction) };
36
37 EncodedJSValue JSC_HOST_CALL boundThisNoArgsFunctionCall(ExecState* exec)
38 {
39     JSBoundFunction* boundFunction = jsCast<JSBoundFunction*>(exec->jsCallee());
40
41     MarkedArgumentBuffer args;
42     for (unsigned i = 0; i < exec->argumentCount(); ++i)
43         args.append(exec->uncheckedArgument(i));
44     RELEASE_ASSERT(!args.hasOverflowed());
45
46     JSFunction* targetFunction = jsCast<JSFunction*>(boundFunction->targetFunction());
47     ExecutableBase* executable = targetFunction->executable();
48     if (executable->hasJITCodeForCall()) {
49         // Force the executable to cache its arity entrypoint.
50         executable->entrypointFor(CodeForCall, MustCheckArity);
51     }
52     CallData callData;
53     CallType callType = getCallData(targetFunction, callData);
54     ASSERT(callType != CallType::None);
55     return JSValue::encode(call(exec, targetFunction, callType, callData, boundFunction->boundThis(), args));
56 }
57
58 EncodedJSValue JSC_HOST_CALL boundFunctionCall(ExecState* exec)
59 {
60     VM& vm = exec->vm();
61     auto scope = DECLARE_THROW_SCOPE(vm);
62     JSBoundFunction* boundFunction = jsCast<JSBoundFunction*>(exec->jsCallee());
63
64     JSArray* boundArgs = boundFunction->boundArgs();
65
66     MarkedArgumentBuffer args;
67     if (boundArgs) {
68         for (unsigned i = 0; i < boundArgs->length(); ++i)
69             args.append(boundArgs->getIndexQuickly(i));
70     }
71     for (unsigned i = 0; i < exec->argumentCount(); ++i)
72         args.append(exec->uncheckedArgument(i));
73     if (UNLIKELY(args.hasOverflowed())) {
74         throwOutOfMemoryError(exec, scope);
75         return encodedJSValue();
76     }
77
78     JSObject* targetFunction = boundFunction->targetFunction();
79     CallData callData;
80     CallType callType = getCallData(targetFunction, callData);
81     ASSERT(callType != CallType::None);
82     scope.release();
83     return JSValue::encode(call(exec, targetFunction, callType, callData, boundFunction->boundThis(), args));
84 }
85
86 EncodedJSValue JSC_HOST_CALL boundThisNoArgsFunctionConstruct(ExecState* exec)
87 {
88     JSBoundFunction* boundFunction = jsCast<JSBoundFunction*>(exec->jsCallee());
89
90     MarkedArgumentBuffer args;
91     for (unsigned i = 0; i < exec->argumentCount(); ++i)
92         args.append(exec->uncheckedArgument(i));
93     RELEASE_ASSERT(!args.hasOverflowed());
94
95     JSFunction* targetFunction = jsCast<JSFunction*>(boundFunction->targetFunction());
96     ConstructData constructData;
97     ConstructType constructType = getConstructData(targetFunction, constructData);
98     ASSERT(constructType != ConstructType::None);
99     return JSValue::encode(construct(exec, targetFunction, constructType, constructData, args));
100 }
101
102 EncodedJSValue JSC_HOST_CALL boundFunctionConstruct(ExecState* exec)
103 {
104     VM& vm = exec->vm();
105     auto scope = DECLARE_THROW_SCOPE(vm);
106     JSBoundFunction* boundFunction = jsCast<JSBoundFunction*>(exec->jsCallee());
107
108     JSArray* boundArgs = boundFunction->boundArgs();
109
110     MarkedArgumentBuffer args;
111     if (boundArgs) {
112         for (unsigned i = 0; i < boundArgs->length(); ++i)
113             args.append(boundArgs->getIndexQuickly(i));
114     }
115     for (unsigned i = 0; i < exec->argumentCount(); ++i)
116         args.append(exec->uncheckedArgument(i));
117     if (UNLIKELY(args.hasOverflowed())) {
118         throwOutOfMemoryError(exec, scope);
119         return encodedJSValue();
120     }
121
122     JSObject* targetFunction = boundFunction->targetFunction();
123     ConstructData constructData;
124     ConstructType constructType = getConstructData(targetFunction, constructData);
125     ASSERT(constructType != ConstructType::None);
126     scope.release();
127     return JSValue::encode(construct(exec, targetFunction, constructType, constructData, args));
128 }
129
130 EncodedJSValue JSC_HOST_CALL isBoundFunction(ExecState* exec)
131 {
132     return JSValue::encode(JSValue(static_cast<bool>(jsDynamicCast<JSBoundFunction*>(exec->vm(), exec->uncheckedArgument(0)))));
133 }
134
135 EncodedJSValue JSC_HOST_CALL hasInstanceBoundFunction(ExecState* exec)
136 {
137     JSBoundFunction* boundObject = jsCast<JSBoundFunction*>(exec->uncheckedArgument(0));
138     JSValue value = exec->uncheckedArgument(1);
139
140     return JSValue::encode(jsBoolean(boundObject->targetFunction()->hasInstance(exec, value)));
141 }
142
143 inline Structure* getBoundFunctionStructure(VM& vm, ExecState* exec, JSGlobalObject* globalObject, JSObject* targetFunction)
144 {
145     auto scope = DECLARE_THROW_SCOPE(vm);
146     JSValue prototype = targetFunction->getPrototype(vm, exec);
147     RETURN_IF_EXCEPTION(scope, nullptr);
148     JSFunction* targetJSFunction = jsDynamicCast<JSFunction*>(vm, targetFunction);
149
150     // We only cache the structure of the bound function if the bindee is a JSFunction since there
151     // isn't any good place to put the structure on Internal Functions.
152     if (targetJSFunction) {
153         Structure* structure = targetJSFunction->rareData(vm)->getBoundFunctionStructure();
154         if (structure && structure->storedPrototype() == prototype && structure->globalObject() == globalObject)
155             return structure;
156     }
157
158     Structure* result = globalObject->boundFunctionStructure();
159
160     // It would be nice if the structure map was keyed global objects in addition to the other things. Unfortunately, it is not
161     // currently. Whoever works on caching structure changes for prototype transistions should consider this problem as well.
162     // See: https://bugs.webkit.org/show_bug.cgi?id=152738
163     if (prototype.isObject() && prototype.getObject()->globalObject() == globalObject) {
164         result = vm.structureCache.emptyStructureForPrototypeFromBaseStructure(globalObject, prototype.getObject(), result);
165         ASSERT_WITH_SECURITY_IMPLICATION(result->globalObject() == globalObject);
166     } else
167         result = Structure::create(vm, globalObject, prototype, result->typeInfo(), result->classInfo());
168
169     if (targetJSFunction)
170         targetJSFunction->rareData(vm)->setBoundFunctionStructure(vm, result);
171
172     return result;
173 }
174
175 JSBoundFunction* JSBoundFunction::create(VM& vm, ExecState* exec, JSGlobalObject* globalObject, JSObject* targetFunction, JSValue boundThis, JSArray* boundArgs, int length, const String& name)
176 {
177     auto scope = DECLARE_THROW_SCOPE(vm);
178     ConstructData constructData;
179     ConstructType constructType = JSC::getConstructData(targetFunction, constructData);
180     bool canConstruct = constructType != ConstructType::None;
181     
182     bool slowCase = boundArgs || !getJSFunction(targetFunction);
183     
184     NativeExecutable* executable = vm.getHostFunction(
185         slowCase ? boundFunctionCall : boundThisNoArgsFunctionCall,
186         slowCase ? NoIntrinsic : BoundThisNoArgsFunctionCallIntrinsic,
187         canConstruct ? (slowCase ? boundFunctionConstruct : boundThisNoArgsFunctionConstruct) : callHostFunctionAsConstructor, nullptr,
188         name);
189     Structure* structure = getBoundFunctionStructure(vm, exec, globalObject, targetFunction);
190     RETURN_IF_EXCEPTION(scope, nullptr);
191     JSBoundFunction* function = new (NotNull, allocateCell<JSBoundFunction>(vm.heap)) JSBoundFunction(vm, globalObject, structure, targetFunction, boundThis, boundArgs);
192
193     function->finishCreation(vm, executable, length);
194     return function;
195 }
196
197 bool JSBoundFunction::customHasInstance(JSObject* object, ExecState* exec, JSValue value)
198 {
199     return jsCast<JSBoundFunction*>(object)->m_targetFunction->hasInstance(exec, value);
200 }
201
202 JSBoundFunction::JSBoundFunction(VM& vm, JSGlobalObject* globalObject, Structure* structure, JSObject* targetFunction, JSValue boundThis, JSArray* boundArgs)
203     : Base(vm, globalObject, structure)
204     , m_targetFunction(vm, this, targetFunction)
205     , m_boundThis(vm, this, boundThis)
206     , m_boundArgs(vm, this, boundArgs, WriteBarrier<JSArray>::MayBeNull)
207 {
208 }
209
210 JSArray* JSBoundFunction::boundArgsCopy(ExecState* exec)
211 {
212     VM& vm = exec->vm();
213     auto scope = DECLARE_THROW_SCOPE(vm);
214     JSArray* result = constructEmptyArray(exec, nullptr, globalObject());
215     RETURN_IF_EXCEPTION(scope, nullptr);
216     for (unsigned i = 0; i < m_boundArgs->length(); ++i) {
217         result->push(exec, m_boundArgs->getIndexQuickly(i));
218         RETURN_IF_EXCEPTION(scope, nullptr);
219     }
220     return result;
221 }
222
223 void JSBoundFunction::finishCreation(VM& vm, NativeExecutable* executable, int length)
224 {
225     String name; // We lazily create our 'name' string property.
226     Base::finishCreation(vm, executable, length, name);
227     ASSERT(inherits(vm, info()));
228 }
229
230 void JSBoundFunction::visitChildren(JSCell* cell, SlotVisitor& visitor)
231 {
232     JSBoundFunction* thisObject = jsCast<JSBoundFunction*>(cell);
233     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
234     Base::visitChildren(thisObject, visitor);
235
236     visitor.append(thisObject->m_targetFunction);
237     visitor.append(thisObject->m_boundThis);
238     visitor.append(thisObject->m_boundArgs);
239 }
240
241 } // namespace JSC