/*
 * Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.nashorn.internal.codegen;

import static jdk.nashorn.internal.lookup.Lookup.MH;

import java.lang.invoke.MethodType;
import java.util.ArrayList;
import java.util.List;
import jdk.nashorn.internal.codegen.types.Type;
import jdk.nashorn.internal.ir.Expression;
import jdk.nashorn.internal.ir.FunctionNode;
import jdk.nashorn.internal.runtime.ScriptFunction;
import jdk.nashorn.internal.runtime.linker.LinkerCallSite;

Class that generates function signatures for dynamic calls
/** * Class that generates function signatures for dynamic calls */
public final class FunctionSignature {
parameter types that ASM can understand
/** parameter types that ASM can understand */
private final Type[] paramTypes;
return type that ASM can understand
/** return type that ASM can understand */
private final Type returnType;
valid Java descriptor string for function
/** valid Java descriptor string for function */
private final String descriptor;
MethodType for function
/** {@link MethodType} for function */
private final MethodType methodType;
Constructor Create a FunctionSignature given arguments as AST Nodes
Params:
  • hasSelf – does the function have a self slot?
  • hasCallee – does the function need a callee variable
  • retType – what is the return type
  • args – argument list of AST Nodes
/** * Constructor * * Create a FunctionSignature given arguments as AST Nodes * * @param hasSelf does the function have a self slot? * @param hasCallee does the function need a callee variable * @param retType what is the return type * @param args argument list of AST Nodes */
public FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final List<? extends Expression> args) { this(hasSelf, hasCallee, retType, FunctionSignature.typeArray(args)); }
Constructor Create a FunctionSignature given arguments as AST Nodes
Params:
  • hasSelf – does the function have a self slot?
  • hasCallee – does the function need a callee variable
  • retType – what is the return type
  • nArgs – number of arguments
/** * Constructor * * Create a FunctionSignature given arguments as AST Nodes * * @param hasSelf does the function have a self slot? * @param hasCallee does the function need a callee variable * @param retType what is the return type * @param nArgs number of arguments */
public FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final int nArgs) { this(hasSelf, hasCallee, retType, FunctionSignature.objectArgs(nArgs)); }
Constructor Create a FunctionSignature given argument types only
Params:
  • hasSelf – does the function have a self slot?
  • hasCallee – does the function have a callee slot?
  • retType – what is the return type
  • argTypes – argument list of AST Nodes
/** * Constructor * * Create a FunctionSignature given argument types only * * @param hasSelf does the function have a self slot? * @param hasCallee does the function have a callee slot? * @param retType what is the return type * @param argTypes argument list of AST Nodes */
private FunctionSignature(final boolean hasSelf, final boolean hasCallee, final Type retType, final Type... argTypes) { final boolean isVarArg; int count = 1; if (argTypes == null) { isVarArg = true; } else { isVarArg = argTypes.length > LinkerCallSite.ARGLIMIT; count = isVarArg ? 1 : argTypes.length; } if (hasCallee) { count++; } if (hasSelf) { count++; } paramTypes = new Type[count]; int next = 0; if (hasCallee) { paramTypes[next++] = Type.typeFor(ScriptFunction.class); } if (hasSelf) { paramTypes[next++] = Type.OBJECT; } if (isVarArg) { paramTypes[next] = Type.OBJECT_ARRAY; } else if (argTypes != null) { for (int j = 0; next < count;) { final Type type = argTypes[j++]; // TODO: for now, turn java/lang/String into java/lang/Object as we aren't as specific. paramTypes[next++] = type.isObject() ? Type.OBJECT : type; } } else { assert false : "isVarArgs cannot be false when argTypes are null"; } this.returnType = retType; this.descriptor = Type.getMethodDescriptor(returnType, paramTypes); final List<Class<?>> paramTypeList = new ArrayList<>(); for (final Type paramType : paramTypes) { paramTypeList.add(paramType.getTypeClass()); } this.methodType = MH.type(returnType.getTypeClass(), paramTypeList.toArray(new Class<?>[0])); }
Create a function signature given a function node, using as much type information for parameters and return types that is available
Params:
  • functionNode – the function node
/** * Create a function signature given a function node, using as much * type information for parameters and return types that is available * * @param functionNode the function node */
public FunctionSignature(final FunctionNode functionNode) { this( true, functionNode.needsCallee(), functionNode.getReturnType(), (functionNode.isVarArg() && !functionNode.isProgram()) ? null : functionNode.getParameters()); }
Internal function that converts an array of nodes to their Types
Params:
  • args – node arg list
Returns:the array of types
/** * Internal function that converts an array of nodes to their Types * * @param args node arg list * * @return the array of types */
private static Type[] typeArray(final List<? extends Expression> args) { if (args == null) { return null; } final Type[] typeArray = new Type[args.size()]; int pos = 0; for (final Expression arg : args) { typeArray[pos++] = arg.getType(); } return typeArray; } @Override public String toString() { return descriptor; }
Returns:the number of param types
/** * @return the number of param types */
public int size() { return paramTypes.length; }
Get the param types for this function signature
Returns:cloned vector of param types
/** * Get the param types for this function signature * @return cloned vector of param types */
public Type[] getParamTypes() { return paramTypes.clone(); }
Return the MethodType for this function signature
Returns:the method type
/** * Return the {@link MethodType} for this function signature * @return the method type */
public MethodType getMethodType() { return methodType; }
Return the return type for this function signature
Returns:the return type
/** * Return the return type for this function signature * @return the return type */
public Type getReturnType() { return returnType; } private static Type[] objectArgs(final int nArgs) { final Type[] array = new Type[nArgs]; for (int i = 0; i < nArgs; i++) { array[i] = Type.OBJECT; } return array; } }