1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.nashorn.internal.runtime;
27
28 import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
29 import static jdk.nashorn.internal.lookup.Lookup.MH;
30 import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
31 import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
32
33 import java.lang.invoke.MethodHandle;
34 import java.lang.invoke.MethodHandles;
35 import java.lang.invoke.MethodType;
36 import jdk.internal.dynalink.CallSiteDescriptor;
37 import jdk.internal.dynalink.linker.GuardedInvocation;
38 import jdk.internal.dynalink.linker.LinkRequest;
39 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
40 import jdk.nashorn.internal.lookup.MethodHandleFactory;
41 import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
42 import jdk.nashorn.internal.runtime.linker.NashornGuards;
43
44 /**
45 * Runtime representation of a JavaScript function.
46 */
47 public abstract class ScriptFunction extends ScriptObject {
48
49 /** Method handle for prototype getter for this ScriptFunction */
50 public static final MethodHandle G$PROTOTYPE = findOwnMH("G$prototype", Object.class, Object.class);
51
52 /** Method handle for prototype setter for this ScriptFunction */
53 public static final MethodHandle S$PROTOTYPE = findOwnMH("S$prototype", void.class, Object.class, Object.class);
54
55 /** Method handle for length getter for this ScriptFunction */
56 public static final MethodHandle G$LENGTH = findOwnMH("G$length", int.class, Object.class);
57
58 /** Method handle for name getter for this ScriptFunction */
59 public static final MethodHandle G$NAME = findOwnMH("G$name", Object.class, Object.class);
60
61 /** Method handle used for implementing sync() in mozilla_compat */
62 public static final MethodHandle INVOKE_SYNC = findOwnMH("invokeSync", Object.class, ScriptFunction.class, Object.class, Object.class, Object[].class);
63
64 /** Method handle for allocate function for this ScriptFunction */
65 static final MethodHandle ALLOCATE = findOwnMH("allocate", Object.class);
66
67 private static final MethodHandle WRAPFILTER = findOwnMH("wrapFilter", Object.class, Object.class);
68
69 private static final MethodHandle GLOBALFILTER = findOwnMH("globalFilter", Object.class, Object.class);
70
71 /** method handle to scope getter for this ScriptFunction */
72 public static final Call GET_SCOPE = virtualCallNoLookup(ScriptFunction.class, "getScope", ScriptObject.class);
73
74 private static final MethodHandle IS_FUNCTION_MH = findOwnMH("isFunctionMH", boolean.class, Object.class, ScriptFunctionData.class);
75
76 private static final MethodHandle IS_NONSTRICT_FUNCTION = findOwnMH("isNonStrictFunction", boolean.class, Object.class, Object.class, ScriptFunctionData.class);
77
78 private static final MethodHandle ADD_ZEROTH_ELEMENT = findOwnMH("addZerothElement", Object[].class, Object[].class, Object.class);
79
80 /** The parent scope. */
81 private final ScriptObject scope;
82
83 private final ScriptFunctionData data;
84
85 /** The property map used for newly allocated object when function is used as constructor. */
86 protected PropertyMap allocatorMap;
87
88 /**
89 * Constructor
90 *
91 * @param name function name
92 * @param methodHandle method handle to function (if specializations are present, assumed to be most generic)
93 * @param map property map
94 * @param scope scope
95 * @param specs specialized version of this function - other method handles
96 * @param flags {@link ScriptFunctionData} flags
97 */
98 protected ScriptFunction(
99 final String name,
100 final MethodHandle methodHandle,
101 final PropertyMap map,
102 final ScriptObject scope,
103 final MethodHandle[] specs,
104 final int flags) {
105
106 this(new FinalScriptFunctionData(name, methodHandle, specs, flags), map, scope);
107 }
108
109 /**
110 * Constructor
111 *
112 * @param data static function data
113 * @param map property map
114 * @param scope scope
115 */
116 protected ScriptFunction(
117 final ScriptFunctionData data,
118 final PropertyMap map,
119 final ScriptObject scope) {
120
121 super(map);
122
123 if (Context.DEBUG) {
124 constructorCount++;
125 }
126
127 this.data = data;
128 this.scope = scope;
129 this.allocatorMap = data.getAllocatorMap();
130 }
131
132 @Override
133 public String getClassName() {
134 return "Function";
135 }
136
137 /**
138 * ECMA 15.3.5.3 [[HasInstance]] (V)
139 * Step 3 if "prototype" value is not an Object, throw TypeError
140 */
141 @Override
142 public boolean isInstance(final ScriptObject instance) {
143 final Object basePrototype = getTargetFunction().getPrototype();
144 if (!(basePrototype instanceof ScriptObject)) {
145 throw typeError("prototype.not.an.object", ScriptRuntime.safeToString(getTargetFunction()), ScriptRuntime.safeToString(basePrototype));
146 }
147
148 for (ScriptObject proto = instance.getProto(); proto != null; proto = proto.getProto()) {
149 if (proto == basePrototype) {
150 return true;
151 }
152 }
153
154 return false;
155 }
156
157 /**
158 * Returns the target function for this function. If the function was not created using
159 * {@link #makeBoundFunction(Object, Object[])}, its target function is itself. If it is bound, its target function
160 * is the target function of the function it was made from (therefore, the target function is always the final,
161 * unbound recipient of the calls).
162 * @return the target function for this function.
163 */
164 protected ScriptFunction getTargetFunction() {
165 return this;
166 }
167
168 boolean isBoundFunction() {
169 return getTargetFunction() != this;
170 }
171
172 /**
173 * Set the arity of this ScriptFunction
174 * @param arity arity
175 */
176 public final void setArity(final int arity) {
177 data.setArity(arity);
178 }
179
180 /**
181 * Is this a ECMAScript 'use strict' function?
182 * @return true if function is in strict mode
183 */
184 public boolean isStrict() {
185 return data.isStrict();
186 }
187
188 /**
189 * Returns true if this is a non-strict, non-built-in function that requires non-primitive this argument
190 * according to ECMA 10.4.3.
191 * @return true if this argument must be an object
192 */
193 public boolean needsWrappedThis() {
194 return data.needsWrappedThis();
195 }
196
197 /**
198 * Execute this script function.
199 * @param self Target object.
200 * @param arguments Call arguments.
201 * @return ScriptFunction result.
202 * @throws Throwable if there is an exception/error with the invocation or thrown from it
203 */
204 Object invoke(final Object self, final Object... arguments) throws Throwable {
205 if (Context.DEBUG) {
206 invokes++;
207 }
208 return data.invoke(this, self, arguments);
209 }
210
211 /**
212 * Execute this script function as a constructor.
213 * @param arguments Call arguments.
214 * @return Newly constructed result.
215 * @throws Throwable if there is an exception/error with the invocation or thrown from it
216 */
217 Object construct(final Object... arguments) throws Throwable {
218 return data.construct(this, arguments);
219 }
220
221 /**
222 * Allocate function. Called from generated {@link ScriptObject} code
223 * for allocation as a factory method
224 *
225 * @return a new instance of the {@link ScriptObject} whose allocator this is
226 */
227 @SuppressWarnings("unused")
228 private Object allocate() {
229 if (Context.DEBUG) {
230 allocations++;
231 }
232 assert !isBoundFunction(); // allocate never invoked on bound functions
233
234 final ScriptObject object = data.allocate(allocatorMap);
235
236 if (object != null) {
237 Object prototype = getPrototype();
238 if (prototype instanceof ScriptObject) {
239 object.setInitialProto((ScriptObject)prototype);
240 }
241
242 if (object.getProto() == null) {
243 object.setInitialProto(getObjectPrototype());
244 }
245 }
246
247 return object;
248 }
249
250 /**
251 * Return Object.prototype - used by "allocate"
252 * @return Object.prototype
253 */
254 protected abstract ScriptObject getObjectPrototype();
255
256 /**
257 * Creates a version of this function bound to a specific "self" and other arguments, as per
258 * {@code Function.prototype.bind} functionality in ECMAScript 5.1 section 15.3.4.5.
259 * @param self the self to bind to this function. Can be null (in which case, null is bound as this).
260 * @param args additional arguments to bind to this function. Can be null or empty to not bind additional arguments.
261 * @return a function with the specified self and parameters bound.
262 */
263 protected ScriptFunction makeBoundFunction(final Object self, final Object[] args) {
264 return makeBoundFunction(data.makeBoundFunctionData(this, self, args));
265 }
266
267 /**
268 * Create a version of this function as in {@link ScriptFunction#makeBoundFunction(Object, Object[])},
269 * but using a {@link ScriptFunctionData} for the bound data.
270 *
271 * @param boundData ScriptFuntionData for the bound function
272 * @return a function with the bindings performed according to the given data
273 */
274 protected abstract ScriptFunction makeBoundFunction(ScriptFunctionData boundData);
275
276 @Override
277 public final String safeToString() {
278 return toSource();
279 }
280
281 @Override
282 public String toString() {
283 return data.toString();
284 }
285
286 /**
287 * Get this function as a String containing its source code. If no source code
288 * exists in this ScriptFunction, its contents will be displayed as {@code [native code]}
289 * @return string representation of this function's source
290 */
291 public final String toSource() {
292 return data.toSource();
293 }
294
295 /**
296 * Get the prototype object for this function
297 * @return prototype
298 */
299 public abstract Object getPrototype();
300
301 /**
302 * Set the prototype object for this function
303 * @param prototype new prototype object
304 */
305 public abstract void setPrototype(Object prototype);
306
307 /**
308 * Create a function that invokes this function synchronized on {@code sync} or the self object
309 * of the invocation.
310 * @param sync the Object to synchronize on, or undefined
311 * @return synchronized function
312 */
313 public abstract ScriptFunction makeSynchronizedFunction(Object sync);
314
315 /**
316 * Return the most appropriate invoke handle if there are specializations
317 * @param type most specific method type to look for invocation with
318 * @param args args for trampoline invocation
319 * @return invoke method handle
320 */
321 private MethodHandle getBestInvoker(final MethodType type, final Object[] args) {
322 return data.getBestInvoker(type, args);
323 }
324
325 /**
326 * Return the most appropriate invoke handle if there are specializations
327 * @param type most specific method type to look for invocation with
328 * @return invoke method handle
329 */
330 public MethodHandle getBestInvoker(final MethodType type) {
331 return getBestInvoker(type, null);
332 }
333
334 /**
335 * Return the invoke handle bound to a given ScriptObject self reference.
336 * If callee parameter is required result is rebound to this.
337 *
338 * @param self self reference
339 * @return bound invoke handle
340 */
341 public final MethodHandle getBoundInvokeHandle(final Object self) {
342 return MH.bindTo(bindToCalleeIfNeeded(data.getGenericInvoker()), self);
343 }
344
345 /**
346 * Bind the method handle to this {@code ScriptFunction} instance if it needs a callee parameter. If this function's
347 * method handles don't have a callee parameter, the handle is returned unchanged.
348 * @param methodHandle the method handle to potentially bind to this function instance.
349 * @return the potentially bound method handle
350 */
351 private MethodHandle bindToCalleeIfNeeded(final MethodHandle methodHandle) {
352 return ScriptFunctionData.needsCallee(methodHandle) ? MH.bindTo(methodHandle, this) : methodHandle;
353
354 }
355
356 /**
357 * Get the name for this function
358 * @return the name
359 */
360 public final String getName() {
361 return data.getName();
362 }
363
364
365 /**
366 * Get the scope for this function
367 * @return the scope
368 */
369 public final ScriptObject getScope() {
370 return scope;
371 }
372
373 /**
374 * Prototype getter for this ScriptFunction - follows the naming convention
375 * used by Nasgen and the code generator
376 *
377 * @param self self reference
378 * @return self's prototype
379 */
380 public static Object G$prototype(final Object self) {
381 return (self instanceof ScriptFunction) ?
382 ((ScriptFunction)self).getPrototype() :
383 UNDEFINED;
384 }
385
386 /**
387 * Prototype setter for this ScriptFunction - follows the naming convention
388 * used by Nasgen and the code generator
389 *
390 * @param self self reference
391 * @param prototype prototype to set
392 */
393 public static void S$prototype(final Object self, final Object prototype) {
394 if (self instanceof ScriptFunction) {
395 ((ScriptFunction)self).setPrototype(prototype);
396 }
397 }
398
399 /**
400 * Length getter - ECMA 15.3.3.2: Function.length
401 * @param self self reference
402 * @return length
403 */
404 public static int G$length(final Object self) {
405 if (self instanceof ScriptFunction) {
406 return ((ScriptFunction)self).data.getArity();
407 }
408
409 return 0;
410 }
411
412 /**
413 * Name getter - ECMA Function.name
414 * @param self self refence
415 * @return the name, or undefined if none
416 */
417 public static Object G$name(final Object self) {
418 if (self instanceof ScriptFunction) {
419 return ((ScriptFunction)self).getName();
420 }
421
422 return UNDEFINED;
423 }
424
425 /**
426 * Get the prototype for this ScriptFunction
427 * @param constructor constructor
428 * @return prototype, or null if given constructor is not a ScriptFunction
429 */
430 public static ScriptObject getPrototype(final Object constructor) {
431 if (constructor instanceof ScriptFunction) {
432 final Object proto = ((ScriptFunction)constructor).getPrototype();
433 if (proto instanceof ScriptObject) {
434 return (ScriptObject)proto;
435 }
436 }
437
438 return null;
439 }
440
441 // These counters are updated only in debug mode.
442 private static int constructorCount;
443 private static int invokes;
444 private static int allocations;
445
446 /**
447 * @return the constructorCount
448 */
449 public static int getConstructorCount() {
450 return constructorCount;
451 }
452
453 /**
454 * @return the invokes
455 */
456 public static int getInvokes() {
457 return invokes;
458 }
459
460 /**
461 * @return the allocations
462 */
463 public static int getAllocations() {
464 return allocations;
465 }
466
467 @Override
468 protected GuardedInvocation findNewMethod(final CallSiteDescriptor desc) {
469 final MethodType type = desc.getMethodType();
470 return new GuardedInvocation(pairArguments(data.getBestConstructor(type.changeParameterType(0, ScriptFunction.class), null), type), null, getFunctionGuard(this));
471 }
472
473 @SuppressWarnings("unused")
474 private static Object wrapFilter(final Object obj) {
475 if (obj instanceof ScriptObject || !ScriptFunctionData.isPrimitiveThis(obj)) {
476 return obj;
477 }
478 return ((GlobalObject)Context.getGlobalTrusted()).wrapAsObject(obj);
479 }
480
481
482 @SuppressWarnings("unused")
483 private static Object globalFilter(final Object object) {
484 // replace whatever we get with the current global object
485 return Context.getGlobalTrusted();
486 }
487
488 /**
489 * dyn:call call site signature: (callee, thiz, [args...])
490 * generated method signature: (callee, thiz, [args...])
491 *
492 * cases:
493 * (a) method has callee parameter
494 * (1) for local/scope calls, we just bind thiz and drop the second argument.
495 * (2) for normal this-calls, we have to swap thiz and callee to get matching signatures.
496 * (b) method doesn't have callee parameter (builtin functions)
497 * (3) for local/scope calls, bind thiz and drop both callee and thiz.
498 * (4) for normal this-calls, drop callee.
499 */
500 @Override
501 protected GuardedInvocation findCallMethod(final CallSiteDescriptor desc, final LinkRequest request) {
502 final MethodType type = desc.getMethodType();
503 final boolean scopeCall = NashornCallSiteDescriptor.isScope(desc);
504
505 if (request.isCallSiteUnstable()) {
506 // (callee, this, args...) => (callee, this, args[])
507 final MethodHandle collector = MH.asCollector(ScriptRuntime.APPLY.methodHandle(), Object[].class, type.parameterCount() - 2);
508
509 // If call site is statically typed to take a ScriptFunction, we don't need a guard, otherwise we need a
510 // generic "is this a ScriptFunction?" guard.
511 return new GuardedInvocation(collector, ScriptFunction.class.isAssignableFrom(desc.getMethodType().parameterType(0))
512 ? null : NashornGuards.getScriptFunctionGuard());
513 }
514
515 MethodHandle boundHandle;
516 MethodHandle guard = null;
517
518 if (data.needsCallee()) {
519 final MethodHandle callHandle = getBestInvoker(type, request.getArguments());
520 if (scopeCall && needsWrappedThis()) {
521 // Make a handle that drops the passed "this" argument and substitutes either Global or Undefined
522 // (callee, this, args...) => (callee, [this], args...)
523 boundHandle = MH.filterArguments(callHandle, 1, GLOBALFILTER);
524 } else {
525 // It's already (callee, this, args...), just what we need
526 boundHandle = callHandle;
527 }
528 } else {
529 final MethodHandle callHandle = getBestInvoker(type.dropParameterTypes(0, 1), request.getArguments());
530 if (data.isBuiltin() && "extend".equals(data.getName())) {
531 // NOTE: the only built-in named "extend" is NativeJava.extend. As a special-case we're binding the
532 // current lookup as its "this" so it can do security-sensitive creation of adapter classes.
533 boundHandle = MH.dropArguments(MH.bindTo(callHandle, desc.getLookup()), 0, Object.class, Object.class);
534 } else if (scopeCall && needsWrappedThis()) {
535 // Make a handle that drops the passed "this" argument and substitutes either Global or Undefined
536 // (this, args...) => ([this], args...)
537 boundHandle = MH.filterArguments(callHandle, 0, GLOBALFILTER);
538 // ([this], args...) => ([callee], [this], args...)
539 boundHandle = MH.dropArguments(boundHandle, 0, Object.class);
540 } else {
541 // (this, args...) => ([callee], this, args...)
542 boundHandle = MH.dropArguments(callHandle, 0, Object.class);
543 }
544 }
545
546 // For non-strict functions, check whether this-object is primitive type.
547 // If so add a to-object-wrapper argument filter.
548 // Else install a guard that will trigger a relink when the argument becomes primitive.
549 if (!scopeCall && needsWrappedThis()) {
550 if (ScriptFunctionData.isPrimitiveThis(request.getArguments()[1])) {
551 boundHandle = MH.filterArguments(boundHandle, 1, WRAPFILTER);
552 } else {
553 guard = getNonStrictFunctionGuard(this);
554 }
555 }
556
557 boundHandle = pairArguments(boundHandle, type);
558
559 return new GuardedInvocation(boundHandle, guard == null ? getFunctionGuard(this) : guard);
560 }
561
562 /**
563 * Used for noSuchMethod/noSuchProperty and JSAdapter hooks.
564 *
565 * These don't want a callee parameter, so bind that. Name binding is optional.
566 */
567 MethodHandle getCallMethodHandle(final MethodType type, final String bindName) {
568 return pairArguments(bindToNameIfNeeded(bindToCalleeIfNeeded(getBestInvoker(type, null)), bindName), type);
569 }
570
571 private static MethodHandle bindToNameIfNeeded(final MethodHandle methodHandle, final String bindName) {
572 if (bindName == null) {
573 return methodHandle;
574 }
575
576 // if it is vararg method, we need to extend argument array with
577 // a new zeroth element that is set to bindName value.
578 final MethodType methodType = methodHandle.type();
579 final int parameterCount = methodType.parameterCount();
580 final boolean isVarArg = parameterCount > 0 && methodType.parameterType(parameterCount - 1).isArray();
581
582 if (isVarArg) {
583 return MH.filterArguments(methodHandle, 1, MH.insertArguments(ADD_ZEROTH_ELEMENT, 1, bindName));
584 }
585 return MH.insertArguments(methodHandle, 1, bindName);
586 }
587
588 /**
589 * Get the guard that checks if a {@link ScriptFunction} is equal to
590 * a known ScriptFunction, using reference comparison
591 *
592 * @param function The ScriptFunction to check against. This will be bound to the guard method handle
593 *
594 * @return method handle for guard
595 */
596 private static MethodHandle getFunctionGuard(final ScriptFunction function) {
597 assert function.data != null;
598 return MH.insertArguments(IS_FUNCTION_MH, 1, function.data);
599 }
600
601 /**
602 * Get a guard that checks if a {@link ScriptFunction} is equal to
603 * a known ScriptFunction using reference comparison, and whether the type of
604 * the second argument (this-object) is not a JavaScript primitive type.
605 *
606 * @param function The ScriptFunction to check against. This will be bound to the guard method handle
607 *
608 * @return method handle for guard
609 */
610 private static MethodHandle getNonStrictFunctionGuard(final ScriptFunction function) {
611 assert function.data != null;
612 return MH.insertArguments(IS_NONSTRICT_FUNCTION, 2, function.data);
613 }
614
615 @SuppressWarnings("unused")
616 private static boolean isFunctionMH(final Object self, final ScriptFunctionData data) {
617 return self instanceof ScriptFunction && ((ScriptFunction)self).data == data;
618 }
619
620 @SuppressWarnings("unused")
621 private static boolean isNonStrictFunction(final Object self, final Object arg, final ScriptFunctionData data) {
622 return self instanceof ScriptFunction && ((ScriptFunction)self).data == data && arg instanceof ScriptObject;
623 }
624
625 @SuppressWarnings("unused")
626 private static Object[] addZerothElement(final Object[] args, final Object value) {
627 // extends input array with by adding new zeroth element
628 final Object[] src = (args == null)? ScriptRuntime.EMPTY_ARRAY : args;
629 final Object[] result = new Object[src.length + 1];
630 System.arraycopy(src, 0, result, 1, src.length);
631 result[0] = value;
632 return result;
633 }
634
635 @SuppressWarnings("unused")
636 private static Object invokeSync(final ScriptFunction func, final Object sync, final Object self, final Object... args)
637 throws Throwable {
638 final Object syncObj = sync == UNDEFINED ? self : sync;
639 synchronized (syncObj) {
640 return func.invoke(self, args);
641 }
642 }
643
644 private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
645 final Class<?> own = ScriptFunction.class;
646 final MethodType mt = MH.type(rtype, types);
647 try {
648 return MH.findStatic(MethodHandles.lookup(), own, name, mt);
649 } catch (final MethodHandleFactory.LookupException e) {
650 return MH.findVirtual(MethodHandles.lookup(), own, name, mt);
651 }
652 }
653 }
654