nashorn/src/jdk/nashorn/internal/codegen/RuntimeCallSite.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2010, 2013, 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.codegen.CompilerConstants.staticCallNoLookup;
 import static jdk.nashorn.internal.codegen.types.Type.BOOLEAN;
 import static jdk.nashorn.internal.codegen.types.Type.INT;
 import static jdk.nashorn.internal.runtime.linker.Lookup.MH;

 import java.lang.invoke.CallSite;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.invoke.MutableCallSite;
 import java.util.HashMap;
 import java.util.Map;
 import jdk.nashorn.internal.codegen.CompilerConstants.Call;
 import jdk.nashorn.internal.codegen.types.Type;
 import jdk.nashorn.internal.ir.RuntimeNode;
 import jdk.nashorn.internal.ir.RuntimeNode.Request;
 import jdk.nashorn.internal.runtime.ScriptRuntime;
 import jdk.nashorn.internal.runtime.linker.Bootstrap;
 import jdk.nashorn.internal.runtime.linker.Lookup;
 import jdk.nashorn.internal.runtime.linker.MethodHandleFactory;

 /**
  * Optimistic call site that assumes its Object arguments to be of a boxed type.
  * Gradually reverts to wider boxed types if the assumption for the RuntimeNode
  * is proven wrong. Finally reverts to the generic ScriptRuntime method.
  *
  * This is used from the CodeGenerator when we have a runtime node, but 1 or more
  * primitive arguments. This class generated appropriate specializations, for example
  * {@code Object a === int b} is a good idea to specialize to {@code ((Integer)a).intValue() == b}
  * surrounded by catch blocks that will try less narrow specializations
  */
 public final class RuntimeCallSite extends MutableCallSite {
     static final Call BOOTSTRAP = staticCallNoLookup(Bootstrap.class, "runtimeBootstrap", CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class);

     private static final MethodHandle NEXT = findOwnMH("next",  MethodHandle.class);

     private final RuntimeNode.Request request;

     private String name;

     /**
      * A specialized runtime node, i.e. on where we know at least one more specific type than object
      */
     static final class SpecializedRuntimeNode {
         private static final char REQUEST_SEPARATOR = ':';

         private final RuntimeNode.Request request;

         private final Type[] parameterTypes;

         private final Type   returnType;

         /**
          * Constructor.
          *
          * @param request        runtime node request to specialize
          * @param parameterTypes parameter types of the call site
          * @param returnType     return type of the call site
          */
         SpecializedRuntimeNode(final RuntimeNode.Request request, final Type[] parameterTypes, final Type returnType) {
             this.request        = request;
             this.parameterTypes = parameterTypes;
             this.returnType     = returnType;
         }

         /**
          * The first type to try to use for this genrated runtime node
          *
          * @return a type
          */
         public Type firstTypeGuess() {
             Type widest = Type.UNKNOWN;
             for (final Type type : parameterTypes) {
                 if (type.isObject()) {
                     continue;
                 }
                 widest = Type.widest(type, widest);
             }
             widest = Type.widest(widest, firstTypeGuessForObject(request));

             return widest;
         }

         private static Type firstTypeGuessForObject(final Request request) {
             switch (request) {
             case ADD:
                 return INT;
             default:
                 return BOOLEAN;
             }
         }

         Request getRequest() {
             return request;
         }

         Type[] getParameterTypes() {
             return parameterTypes;
         }

         Type getReturnType() {
             return returnType;
         }

         private static char descFor(final Type type) {
             if (type.isObject()) {
                 return 'O';
             }
             return type.getDescriptor().charAt(0);
         }

         @Override
         public boolean equals(final Object other) {
             if (other instanceof SpecializedRuntimeNode) {
                 final SpecializedRuntimeNode otherNode = (SpecializedRuntimeNode)other;

                 if (!otherNode.getReturnType().equals(getReturnType())) {
                     return false;
                 }

                 if (getParameterTypes().length != otherNode.getParameterTypes().length) {
                     return false;
                 }

                 for (int i = 0; i < getParameterTypes().length; i++) {
                     if (!Type.areEquivalent(getParameterTypes()[i], otherNode.getParameterTypes()[i])) {
                         return false;
                     }
                 }

                 return otherNode.getRequest().equals(getRequest());
             }

             return false;
         }

         @Override
         public int hashCode() {
             int hashCode = getRequest().toString().hashCode();
             hashCode ^= getReturnType().hashCode();
             for (final Type type : getParameterTypes()) {
                 hashCode ^= type.hashCode();
             }
             return hashCode;
         }

         @Override
         public String toString() {
             final StringBuilder sb = new StringBuilder();
             sb.append(getRequest().toString());
             sb.append(REQUEST_SEPARATOR);
             sb.append(descFor(getReturnType()));

             for (final Type type : getParameterTypes()) {
                 sb.append(descFor(type));
             }

             return sb.toString();
         }

         String getName(final Type extraType) {
             return toString() + "_" + descFor(extraType);
         }

         String getInitialName() {
             return getName(firstTypeGuess());
         }
     }


     /**
      * Constructor
      *
      * @param type method type for call site
      * @param name name of runtime call
      */
     public RuntimeCallSite(final MethodType type, final String name) {
         super(type);
         this.name    = name;
         this.request = Request.valueOf(name.substring(0, name.indexOf(SpecializedRuntimeNode.REQUEST_SEPARATOR)));
         setTarget(makeMethod(name));
     }

     private String nextName(final String requestName) {
         if (requestName.equals(request.toString())) {
             return null;
         }

         final char[] c = requestName.toCharArray();
         final int last = c.length - 1;

         if (c[last - 1] != '_') {
             return null;
         }

         switch (c[last]) {
         case 'Z':
             c[last] = 'I';
             break;
         case 'I':
             c[last] = 'J';
             break;
         case 'J':
             c[last] = 'D';
             break;
         case 'D':
         default:
             return request.toString();
         }

         return new String(c);
     }

     private boolean isSpecialized(final String requestName) {
         return nextName(requestName) != null;
     }

     private MethodHandle makeMethod(final String requestName) {
         MethodHandle mh;

         if (isSpecialized(requestName)) {
             final Class<?> boxedType;
             final Class<?> primitiveType;

             switch (requestName.charAt(requestName.length() - 1)) {
             case 'Z':
                 boxedType = Boolean.class;
                 primitiveType = int.class;
                 break;
             case 'I':
                 boxedType = Integer.class;
                 primitiveType = int.class;
                 break;
             case 'J':
                 boxedType = Long.class;
                 primitiveType = long.class;
                 break;
             case 'D':
                 boxedType = Number.class;
                 primitiveType = double.class;
                 break;
             default:
                 throw new RuntimeException("should not reach here");
             }

             final boolean isStrictCmp = (request == Request.EQ_STRICT || request == Request.NE_STRICT);

             if (isStrictCmp &&
                     (boxedType != Boolean.class &&
                         (type().parameterType(0) == boolean.class ||
                          type().parameterType(1) == boolean.class))) {
                 // number and boolean are never strictly equal, e.g. 0 !== false
                 mh = MH.dropArguments(MH.constant(boolean.class, request == Request.NE_STRICT), 0, type().parameterArray());
             } else {
                 mh = METHODS.get(request.nonStrictName() + primitiveType.getSimpleName());
                 // unbox objects

                 for (int i = 0; i < type().parameterCount(); i++) {
                     if (!type().parameterType(i).isPrimitive()) {
                         mh = MH.filterArguments(mh, i, UNBOX.get(boxedType));
                     }
                 }

                 mh = Lookup.filterReturnType(mh, type().returnType());
                 mh = MH.explicitCastArguments(mh, type());
             }

             final MethodHandle fallback = MH.foldArguments(MethodHandles.exactInvoker(type()), MH.bindTo(NEXT, this));

             MethodHandle guard;
             if (type().parameterType(0).isPrimitive()) {
                 guard = MH.insertArguments(
                             MH.dropArguments(CHECKCAST, 1, type().parameterType(0)), 0, boxedType);
             } else if (type().parameterType(1).isPrimitive()) {
                 guard = MH.insertArguments(
                             MH.dropArguments(CHECKCAST, 2, type().parameterType(1)), 0, boxedType);
             } else {
                 assert !type().parameterType(0).isPrimitive() && !type().parameterType(1).isPrimitive();
                 guard = MH.insertArguments(CHECKCAST2, 0, boxedType);
             }

             if (request == Request.ADD && boxedType == Integer.class) {
                 // int add needs additional overflow check
                 MethodHandle addcheck = ADDCHECK;
                 for (int i = 0; i < type().parameterCount(); i++) {
                     if (!type().parameterType(i).isPrimitive()) {
                         addcheck = MH.filterArguments(addcheck, i, UNBOX.get(boxedType));
                     }
                 }
                 addcheck = MH.explicitCastArguments(addcheck, type().changeReturnType(boolean.class));
                 guard    = MH.guardWithTest(upcastGuard(guard), addcheck,
                                 MH.dropArguments(MH.constant(boolean.class, false), 0, type().parameterArray()));
             }

             return MH.guardWithTest(upcastGuard(guard), mh, fallback);
         }

         // generic fallback
         return MH.explicitCastArguments(Lookup.filterReturnType(GENERIC_METHODS.get(request.name()), type().returnType()), type());
     }

     private MethodHandle upcastGuard(final MethodHandle guard) {
         return MH.asType(guard, type().changeReturnType(boolean.class));
     }

     /**
      * This is public just so that the generated specialization code can
      * use it to get the next wider typed method
      *
      * Do not call directly
      *
      * @return next wider specialization method for this RuntimeCallSite
      */
     public MethodHandle next() {
         this.name = nextName(name);
         final MethodHandle next = makeMethod(name);
         setTarget(next);
         return next;
     }

     @Override
     public String toString() {
         return super.toString() + " " + name;
     }

     /** Method cache */
     private static final Map<String, MethodHandle> METHODS;

     /** Generic method cache */
     private static final Map<String, MethodHandle> GENERIC_METHODS;

     /** Unbox cache */
     private static final Map<Class<?>, MethodHandle> UNBOX;

     private static final MethodHandle CHECKCAST  = findOwnMH("checkcast", boolean.class, Class.class, Object.class);
     private static final MethodHandle CHECKCAST2 = findOwnMH("checkcast", boolean.class, Class.class, Object.class, Object.class);
     private static final MethodHandle ADDCHECK   = findOwnMH("ADDcheck",  boolean.class, int.class, int.class);

     /**
      * Build maps of correct boxing operations
      */
     static {
         UNBOX = new HashMap<>();
         UNBOX.put(Boolean.class, findOwnMH("unboxZ", int.class, Object.class));
         UNBOX.put(Integer.class, findOwnMH("unboxI", int.class, Object.class));
         UNBOX.put(Long.class,    findOwnMH("unboxJ", long.class, Object.class));
         UNBOX.put(Number.class,  findOwnMH("unboxD", double.class, Object.class));

         METHODS = new HashMap<>();

         for (final Request req : Request.values()) {
             if (req.canSpecialize()) {
                 if (req.name().endsWith("_STRICT")) {
                     continue;
                 }

                 final boolean isCmp = Request.isComparison(req);

                 METHODS.put(req.name() + "int",    findOwnMH(req.name(), (isCmp ? boolean.class : int.class),  int.class, int.class));
                 METHODS.put(req.name() + "long",   findOwnMH(req.name(), (isCmp ? boolean.class : long.class), long.class, long.class));
                 METHODS.put(req.name() + "double", findOwnMH(req.name(), (isCmp ? boolean.class : double.class), double.class, double.class));
             }
         }

         GENERIC_METHODS = new HashMap<>();
         for (final Request req : Request.values()) {
             if (req.canSpecialize()) {
                 GENERIC_METHODS.put(req.name(), MH.findStatic(MethodHandles.lookup(), ScriptRuntime.class, req.name(),
                         MH.type(req.getReturnType().getTypeClass(), Object.class, Object.class)));
             }
         }
     }

     /**
      * Specialized version of != operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a != b
      */
     public static boolean NE(final int a, final int b) {
         return a != b;
     }

     /**
      * Specialized version of != operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a != b
      */
     public static boolean NE(final double a, final double b) {
         return a != b;
     }

     /**
      * Specialized version of != operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a != b
      */
     public static boolean NE(final long a, final long b) {
         return a != b;
     }

     /**
      * Specialized version of == operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a == b
      */
     public static boolean EQ(final int a, final int b) {
         return a == b;
     }

     /**
      * Specialized version of == operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a == b
      */
     public static boolean EQ(final double a, final double b) {
         return a == b;
     }

     /**
      * Specialized version of == operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a == b
      */
     public static boolean EQ(final long a, final long b) {
         return a == b;
     }

     /**
      * Specialized version of {@literal <} operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a {@code <} b
      */
     public static boolean LT(final int a, final int b) {
         return a < b;
     }

     /**
      * Specialized version of {@literal <} operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a {@literal <} b
      */
     public static boolean LT(final double a, final double b) {
         return a < b;
     }

     /**
      * Specialized version of {@literal <} operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a {@literal <} b
      */
     public static boolean LT(final long a, final long b) {
         return a < b;
     }

     /**
      * Specialized version of {@literal <=} operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a {@literal <=} b
      */
     public static boolean LE(final int a, final int b) {
         return a <= b;
     }

     /**
      * Specialized version of {@literal <=} operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a {@literal <=} b
      */
     public static boolean LE(final double a, final double b) {
         return a <= b;
     }

     /**
      * Specialized version of {@literal <=} operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a {@literal <=} b
      */
     public static boolean LE(final long a, final long b) {
         return a <= b;
     }

     /**
      * Specialized version of {@literal >} operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a {@literal >} b
      */
     public static boolean GT(final int a, final int b) {
         return a > b;
     }

     /**
      * Specialized version of {@literal >} operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a {@literal >} b
      */
     public static boolean GT(final double a, final double b) {
         return a > b;
     }

     /**
      * Specialized version of {@literal >} operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a {@literal >} b
      */
     public static boolean GT(final long a, final long b) {
         return a > b;
     }

     /**
      * Specialized version of {@literal >=} operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a {@literal >=} b
      */
     public static boolean GE(final int a, final int b) {
         return a >= b;
     }

     /**
      * Specialized version of {@literal >=} operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a {@literal >=} b
      */
     public static boolean GE(final double a, final double b) {
         return a >= b;
     }

     /**
      * Specialized version of {@literal >=} operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a {@code >=} b
      */
     public static boolean GE(final long a, final long b) {
         return a >= b;
     }

     /**
      * Specialized version of + operator for two int arguments. Do not call directly.
      * @param a int
      * @param b int
      * @return a + b
      */
     public static int ADD(final int a, final int b) {
         return a + b;
     }

     /**
      * Specialized version of + operator for two long arguments. Do not call directly.
      * @param a long
      * @param b long
      * @return a + b
      */
     public static long ADD(final long a, final long b) {
         return a + b;
     }

     /**
      * Specialized version of + operator for two double arguments. Do not call directly.
      * @param a double
      * @param b double
      * @return a + b
      */
     public static double ADD(final double a, final double b) {
         return a + b;
     }

     /**
      * Check that ints are addition compatible, i.e. their sum is equal to the sum
      * of them cast to long. Otherwise the addition will overflow. Do not call directly.
      *
      * @param a int
      * @param b int
      *
      * @return true if addition does not overflow
      */
     public static boolean ADDcheck(final int a, final int b) {
         return (a + b == (long)a + (long)b);
     }

     /**
      * Checkcast used for specialized ops. Do not call directly
      *
      * @param type to to check against
      * @param obj  object to check for type
      *
      * @return true if type check holds
      */
     public static boolean checkcast(final Class<?> type, final Object obj) {
         return type.isInstance(obj);
     }

     /**
      * Checkcast used for specialized ops. Do not call directly
      *
      * @param type type to check against
      * @param objA first object to check against type
      * @param objB second object to check against type
      *
      * @return true if type check holds for both objects
      */
     public static boolean checkcast(final Class<?> type, final Object objA, final Object objB) {
         return type.isInstance(objA) && type.isInstance(objB);
     }

     /**
      * Unbox a java.lang.Boolean. Do not call directly
      * @param obj object to cast to int and unbox
      * @return an int value for the boolean, 1 is true, 0 is false
      */
     public static int unboxZ(final Object obj) {
         return (boolean)obj ? 1 : 0;
     }

     /**
      * Unbox a java.lang.Integer. Do not call directly
      * @param obj object to cast to int and unbox
      * @return an int
      */
     public static int unboxI(final Object obj) {
         return (int)obj;
     }

     /**
      * Unbox a java.lang.Long. Do not call directly
      * @param obj object to cast to long and unbox
      * @return a long
      */
     public static long unboxJ(final Object obj) {
         return (long)obj;
     }

     /**
      * Unbox a java.lang.Number. Do not call directly
      * @param obj object to cast to Number and unbox
      * @return a double
      */
     public static double unboxD(final Object obj) {
         return ((Number)obj).doubleValue();
     }

     private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
         try {
             return MH.findStatic(MethodHandles.lookup(), RuntimeCallSite.class, name, MH.type(rtype, types));
         } catch (final MethodHandleFactory.LookupException e) {
             return MH.findVirtual(MethodHandles.lookup(), RuntimeCallSite.class, name, MH.type(rtype, types));
         }
     }

 }
	/*
	* Copyright (c) 2010, 2013, 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.codegen.CompilerConstants.staticCallNoLookup;
	import static jdk.nashorn.internal.codegen.types.Type.BOOLEAN;
	import static jdk.nashorn.internal.codegen.types.Type.INT;
	import static jdk.nashorn.internal.runtime.linker.Lookup.MH;

	import java.lang.invoke.CallSite;
	import java.lang.invoke.MethodHandle;
	import java.lang.invoke.MethodHandles;
	import java.lang.invoke.MethodType;
	import java.lang.invoke.MutableCallSite;
	import java.util.HashMap;
	import java.util.Map;
	import jdk.nashorn.internal.codegen.CompilerConstants.Call;
	import jdk.nashorn.internal.codegen.types.Type;
	import jdk.nashorn.internal.ir.RuntimeNode;
	import jdk.nashorn.internal.ir.RuntimeNode.Request;
	import jdk.nashorn.internal.runtime.ScriptRuntime;
	import jdk.nashorn.internal.runtime.linker.Bootstrap;
	import jdk.nashorn.internal.runtime.linker.Lookup;
	import jdk.nashorn.internal.runtime.linker.MethodHandleFactory;

	/**
	* Optimistic call site that assumes its Object arguments to be of a boxed type.
	* Gradually reverts to wider boxed types if the assumption for the RuntimeNode
	* is proven wrong. Finally reverts to the generic ScriptRuntime method.
	*
	* This is used from the CodeGenerator when we have a runtime node, but 1 or more
	* primitive arguments. This class generated appropriate specializations, for example
	* {@code Object a === int b} is a good idea to specialize to {@code ((Integer)a).intValue() == b}
	* surrounded by catch blocks that will try less narrow specializations
	*/
	public final class RuntimeCallSite extends MutableCallSite {
	static final Call BOOTSTRAP = staticCallNoLookup(Bootstrap.class, "runtimeBootstrap", CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class);

	private static final MethodHandle NEXT = findOwnMH("next", MethodHandle.class);

	private final RuntimeNode.Request request;

	private String name;

	/**
	* A specialized runtime node, i.e. on where we know at least one more specific type than object
	*/
	static final class SpecializedRuntimeNode {
	private static final char REQUEST_SEPARATOR = ':';

	private final RuntimeNode.Request request;

	private final Type[] parameterTypes;

	private final Type returnType;

	/**
	* Constructor.
	*
	* @param request runtime node request to specialize
	* @param parameterTypes parameter types of the call site
	* @param returnType return type of the call site
	*/
	SpecializedRuntimeNode(final RuntimeNode.Request request, final Type[] parameterTypes, final Type returnType) {
	this.request = request;
	this.parameterTypes = parameterTypes;
	this.returnType = returnType;
	}

	/**
	* The first type to try to use for this genrated runtime node
	*
	* @return a type
	*/
	public Type firstTypeGuess() {
	Type widest = Type.UNKNOWN;
	for (final Type type : parameterTypes) {
	if (type.isObject()) {
	continue;
	}
	widest = Type.widest(type, widest);
	}
	widest = Type.widest(widest, firstTypeGuessForObject(request));

	return widest;
	}

	private static Type firstTypeGuessForObject(final Request request) {
	switch (request) {
	case ADD:
	return INT;
	default:
	return BOOLEAN;
	}
	}

	Request getRequest() {
	return request;
	}

	Type[] getParameterTypes() {
	return parameterTypes;
	}

	Type getReturnType() {
	return returnType;
	}

	private static char descFor(final Type type) {
	if (type.isObject()) {
	return 'O';
	}
	return type.getDescriptor().charAt(0);
	}

	@Override
	public boolean equals(final Object other) {
	if (other instanceof SpecializedRuntimeNode) {
	final SpecializedRuntimeNode otherNode = (SpecializedRuntimeNode)other;

	if (!otherNode.getReturnType().equals(getReturnType())) {
	return false;
	}

	if (getParameterTypes().length != otherNode.getParameterTypes().length) {
	return false;
	}

	for (int i = 0; i < getParameterTypes().length; i++) {
	if (!Type.areEquivalent(getParameterTypes()[i], otherNode.getParameterTypes()[i])) {
	return false;
	}
	}

	return otherNode.getRequest().equals(getRequest());
	}

	return false;
	}

	@Override
	public int hashCode() {
	int hashCode = getRequest().toString().hashCode();
	hashCode ^= getReturnType().hashCode();
	for (final Type type : getParameterTypes()) {
	hashCode ^= type.hashCode();
	}
	return hashCode;
	}

	@Override
	public String toString() {
	final StringBuilder sb = new StringBuilder();
	sb.append(getRequest().toString());
	sb.append(REQUEST_SEPARATOR);
	sb.append(descFor(getReturnType()));

	for (final Type type : getParameterTypes()) {
	sb.append(descFor(type));
	}

	return sb.toString();
	}

	String getName(final Type extraType) {
	return toString() + "_" + descFor(extraType);
	}

	String getInitialName() {
	return getName(firstTypeGuess());
	}
	}


	/**
	* Constructor
	*
	* @param type method type for call site
	* @param name name of runtime call
	*/
	public RuntimeCallSite(final MethodType type, final String name) {
	super(type);
	this.name = name;
	this.request = Request.valueOf(name.substring(0, name.indexOf(SpecializedRuntimeNode.REQUEST_SEPARATOR)));
	setTarget(makeMethod(name));
	}

	private String nextName(final String requestName) {
	if (requestName.equals(request.toString())) {
	return null;
	}

	final char[] c = requestName.toCharArray();
	final int last = c.length - 1;

	if (c[last - 1] != '_') {
	return null;
	}

	switch (c[last]) {
	case 'Z':
	c[last] = 'I';
	break;
	case 'I':
	c[last] = 'J';
	break;
	case 'J':
	c[last] = 'D';
	break;
	case 'D':
	default:
	return request.toString();
	}

	return new String(c);
	}

	private boolean isSpecialized(final String requestName) {
	return nextName(requestName) != null;
	}

	private MethodHandle makeMethod(final String requestName) {
	MethodHandle mh;

	if (isSpecialized(requestName)) {
	final Class<?> boxedType;
	final Class<?> primitiveType;

	switch (requestName.charAt(requestName.length() - 1)) {
	case 'Z':
	boxedType = Boolean.class;
	primitiveType = int.class;
	break;
	case 'I':
	boxedType = Integer.class;
	primitiveType = int.class;
	break;
	case 'J':
	boxedType = Long.class;
	primitiveType = long.class;
	break;
	case 'D':
	boxedType = Number.class;
	primitiveType = double.class;
	break;
	default:
	throw new RuntimeException("should not reach here");
	}

	final boolean isStrictCmp = (request == Request.EQ_STRICT \|\| request == Request.NE_STRICT);

	if (isStrictCmp &&
	(boxedType != Boolean.class &&
	(type().parameterType(0) == boolean.class \|\|
	type().parameterType(1) == boolean.class))) {
	// number and boolean are never strictly equal, e.g. 0 !== false
	mh = MH.dropArguments(MH.constant(boolean.class, request == Request.NE_STRICT), 0, type().parameterArray());
	} else {
	mh = METHODS.get(request.nonStrictName() + primitiveType.getSimpleName());
	// unbox objects

	for (int i = 0; i < type().parameterCount(); i++) {
	if (!type().parameterType(i).isPrimitive()) {
	mh = MH.filterArguments(mh, i, UNBOX.get(boxedType));
	}
	}

	mh = Lookup.filterReturnType(mh, type().returnType());
	mh = MH.explicitCastArguments(mh, type());
	}

	final MethodHandle fallback = MH.foldArguments(MethodHandles.exactInvoker(type()), MH.bindTo(NEXT, this));

	MethodHandle guard;
	if (type().parameterType(0).isPrimitive()) {
	guard = MH.insertArguments(
	MH.dropArguments(CHECKCAST, 1, type().parameterType(0)), 0, boxedType);
	} else if (type().parameterType(1).isPrimitive()) {
	guard = MH.insertArguments(
	MH.dropArguments(CHECKCAST, 2, type().parameterType(1)), 0, boxedType);
	} else {
	assert !type().parameterType(0).isPrimitive() && !type().parameterType(1).isPrimitive();
	guard = MH.insertArguments(CHECKCAST2, 0, boxedType);
	}

	if (request == Request.ADD && boxedType == Integer.class) {
	// int add needs additional overflow check
	MethodHandle addcheck = ADDCHECK;
	for (int i = 0; i < type().parameterCount(); i++) {
	if (!type().parameterType(i).isPrimitive()) {
	addcheck = MH.filterArguments(addcheck, i, UNBOX.get(boxedType));
	}
	}
	addcheck = MH.explicitCastArguments(addcheck, type().changeReturnType(boolean.class));
	guard = MH.guardWithTest(upcastGuard(guard), addcheck,
	MH.dropArguments(MH.constant(boolean.class, false), 0, type().parameterArray()));
	}

	return MH.guardWithTest(upcastGuard(guard), mh, fallback);
	}

	// generic fallback
	return MH.explicitCastArguments(Lookup.filterReturnType(GENERIC_METHODS.get(request.name()), type().returnType()), type());
	}

	private MethodHandle upcastGuard(final MethodHandle guard) {
	return MH.asType(guard, type().changeReturnType(boolean.class));
	}

	/**
	* This is public just so that the generated specialization code can
	* use it to get the next wider typed method
	*
	* Do not call directly
	*
	* @return next wider specialization method for this RuntimeCallSite
	*/
	public MethodHandle next() {
	this.name = nextName(name);
	final MethodHandle next = makeMethod(name);
	setTarget(next);
	return next;
	}

	@Override
	public String toString() {
	return super.toString() + " " + name;
	}

	/** Method cache */
	private static final Map<String, MethodHandle> METHODS;

	/** Generic method cache */
	private static final Map<String, MethodHandle> GENERIC_METHODS;

	/** Unbox cache */
	private static final Map<Class<?>, MethodHandle> UNBOX;

	private static final MethodHandle CHECKCAST = findOwnMH("checkcast", boolean.class, Class.class, Object.class);
	private static final MethodHandle CHECKCAST2 = findOwnMH("checkcast", boolean.class, Class.class, Object.class, Object.class);
	private static final MethodHandle ADDCHECK = findOwnMH("ADDcheck", boolean.class, int.class, int.class);

	/**
	* Build maps of correct boxing operations
	*/
	static {
	UNBOX = new HashMap<>();
	UNBOX.put(Boolean.class, findOwnMH("unboxZ", int.class, Object.class));
	UNBOX.put(Integer.class, findOwnMH("unboxI", int.class, Object.class));
	UNBOX.put(Long.class, findOwnMH("unboxJ", long.class, Object.class));
	UNBOX.put(Number.class, findOwnMH("unboxD", double.class, Object.class));

	METHODS = new HashMap<>();

	for (final Request req : Request.values()) {
	if (req.canSpecialize()) {
	if (req.name().endsWith("_STRICT")) {
	continue;
	}

	final boolean isCmp = Request.isComparison(req);

	METHODS.put(req.name() + "int", findOwnMH(req.name(), (isCmp ? boolean.class : int.class), int.class, int.class));
	METHODS.put(req.name() + "long", findOwnMH(req.name(), (isCmp ? boolean.class : long.class), long.class, long.class));
	METHODS.put(req.name() + "double", findOwnMH(req.name(), (isCmp ? boolean.class : double.class), double.class, double.class));
	}
	}

	GENERIC_METHODS = new HashMap<>();
	for (final Request req : Request.values()) {
	if (req.canSpecialize()) {
	GENERIC_METHODS.put(req.name(), MH.findStatic(MethodHandles.lookup(), ScriptRuntime.class, req.name(),
	MH.type(req.getReturnType().getTypeClass(), Object.class, Object.class)));
	}
	}
	}

	/**
	* Specialized version of != operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a != b
	*/
	public static boolean NE(final int a, final int b) {
	return a != b;
	}

	/**
	* Specialized version of != operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a != b
	*/
	public static boolean NE(final double a, final double b) {
	return a != b;
	}

	/**
	* Specialized version of != operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a != b
	*/
	public static boolean NE(final long a, final long b) {
	return a != b;
	}

	/**
	* Specialized version of == operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a == b
	*/
	public static boolean EQ(final int a, final int b) {
	return a == b;
	}

	/**
	* Specialized version of == operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a == b
	*/
	public static boolean EQ(final double a, final double b) {
	return a == b;
	}

	/**
	* Specialized version of == operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a == b
	*/
	public static boolean EQ(final long a, final long b) {
	return a == b;
	}

	/**
	* Specialized version of {@literal <} operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a {@code <} b
	*/
	public static boolean LT(final int a, final int b) {
	return a < b;
	}

	/**
	* Specialized version of {@literal <} operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a {@literal <} b
	*/
	public static boolean LT(final double a, final double b) {
	return a < b;
	}

	/**
	* Specialized version of {@literal <} operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a {@literal <} b
	*/
	public static boolean LT(final long a, final long b) {
	return a < b;
	}

	/**
	* Specialized version of {@literal <=} operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a {@literal <=} b
	*/
	public static boolean LE(final int a, final int b) {
	return a <= b;
	}

	/**
	* Specialized version of {@literal <=} operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a {@literal <=} b
	*/
	public static boolean LE(final double a, final double b) {
	return a <= b;
	}

	/**
	* Specialized version of {@literal <=} operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a {@literal <=} b
	*/
	public static boolean LE(final long a, final long b) {
	return a <= b;
	}

	/**
	* Specialized version of {@literal >} operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a {@literal >} b
	*/
	public static boolean GT(final int a, final int b) {
	return a > b;
	}

	/**
	* Specialized version of {@literal >} operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a {@literal >} b
	*/
	public static boolean GT(final double a, final double b) {
	return a > b;
	}

	/**
	* Specialized version of {@literal >} operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a {@literal >} b
	*/
	public static boolean GT(final long a, final long b) {
	return a > b;
	}

	/**
	* Specialized version of {@literal >=} operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a {@literal >=} b
	*/
	public static boolean GE(final int a, final int b) {
	return a >= b;
	}

	/**
	* Specialized version of {@literal >=} operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a {@literal >=} b
	*/
	public static boolean GE(final double a, final double b) {
	return a >= b;
	}

	/**
	* Specialized version of {@literal >=} operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a {@code >=} b
	*/
	public static boolean GE(final long a, final long b) {
	return a >= b;
	}

	/**
	* Specialized version of + operator for two int arguments. Do not call directly.
	* @param a int
	* @param b int
	* @return a + b
	*/
	public static int ADD(final int a, final int b) {
	return a + b;
	}

	/**
	* Specialized version of + operator for two long arguments. Do not call directly.
	* @param a long
	* @param b long
	* @return a + b
	*/
	public static long ADD(final long a, final long b) {
	return a + b;
	}

	/**
	* Specialized version of + operator for two double arguments. Do not call directly.
	* @param a double
	* @param b double
	* @return a + b
	*/
	public static double ADD(final double a, final double b) {
	return a + b;
	}

	/**
	* Check that ints are addition compatible, i.e. their sum is equal to the sum
	* of them cast to long. Otherwise the addition will overflow. Do not call directly.
	*
	* @param a int
	* @param b int
	*
	* @return true if addition does not overflow
	*/
	public static boolean ADDcheck(final int a, final int b) {
	return (a + b == (long)a + (long)b);
	}

	/**
	* Checkcast used for specialized ops. Do not call directly
	*
	* @param type to to check against
	* @param obj object to check for type
	*
	* @return true if type check holds
	*/
	public static boolean checkcast(final Class<?> type, final Object obj) {
	return type.isInstance(obj);
	}

	/**
	* Checkcast used for specialized ops. Do not call directly
	*
	* @param type type to check against
	* @param objA first object to check against type
	* @param objB second object to check against type
	*
	* @return true if type check holds for both objects
	*/
	public static boolean checkcast(final Class<?> type, final Object objA, final Object objB) {
	return type.isInstance(objA) && type.isInstance(objB);
	}

	/**
	* Unbox a java.lang.Boolean. Do not call directly
	* @param obj object to cast to int and unbox
	* @return an int value for the boolean, 1 is true, 0 is false
	*/
	public static int unboxZ(final Object obj) {
	return (boolean)obj ? 1 : 0;
	}

	/**
	* Unbox a java.lang.Integer. Do not call directly
	* @param obj object to cast to int and unbox
	* @return an int
	*/
	public static int unboxI(final Object obj) {
	return (int)obj;
	}

	/**
	* Unbox a java.lang.Long. Do not call directly
	* @param obj object to cast to long and unbox
	* @return a long
	*/
	public static long unboxJ(final Object obj) {
	return (long)obj;
	}

	/**
	* Unbox a java.lang.Number. Do not call directly
	* @param obj object to cast to Number and unbox
	* @return a double
	*/
	public static double unboxD(final Object obj) {
	return ((Number)obj).doubleValue();
	}

	private static MethodHandle findOwnMH(final String name, final Class<?> rtype, final Class<?>... types) {
	try {
	return MH.findStatic(MethodHandles.lookup(), RuntimeCallSite.class, name, MH.type(rtype, types));
	} catch (final MethodHandleFactory.LookupException e) {
	return MH.findVirtual(MethodHandles.lookup(), RuntimeCallSite.class, name, MH.type(rtype, types));
	}
	}

	}