Java tutorial
/* * Copyright 2008 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.google.gwt.dev.shell.rewrite; import com.google.gwt.dev.shell.JavaScriptHost; import com.google.gwt.dev.util.Name.InternalName; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.commons.GeneratorAdapter; import org.objectweb.asm.commons.Method; import java.lang.reflect.Modifier; import java.util.Locale; import java.util.Map; /** * Turns native method declarations into normal Java functions which perform the * corresponding JSNI dispatch. */ public class RewriteJsniMethods extends ClassVisitor { /** * Fast way to look up boxing methods. */ private static class Boxing { /** * A matching list of boxed types for each primitive type. */ private static final Type[] BOXED_TYPES = new Type[] { VOID_TYPE, BOOLEAN_TYPE, CHARACTER_TYPE, BYTE_TYPE, SHORT_TYPE, INTEGER_TYPE, FLOAT_TYPE, LONG_TYPE, DOUBLE_TYPE, }; /** * The list of primitive types. */ private static final Type[] PRIMITIVE_TYPES = new Type[] { Type.VOID_TYPE, Type.BOOLEAN_TYPE, Type.CHAR_TYPE, Type.BYTE_TYPE, Type.SHORT_TYPE, Type.INT_TYPE, Type.FLOAT_TYPE, Type.LONG_TYPE, Type.DOUBLE_TYPE, }; /** * A map of Type.sort() to valueOf Method. There are 11 possible results * from Type.sort(), 0 through 10. */ private static final Method[] SORT_MAP = new Method[11]; static { assert PRIMITIVE_TYPES.length == BOXED_TYPES.length; for (int i = 0; i < PRIMITIVE_TYPES.length; ++i) { Type primitive = PRIMITIVE_TYPES[i]; Type boxed = BOXED_TYPES[i]; if (boxed != null) { SORT_MAP[i] = new Method("valueOf", boxed, new Type[] { primitive }); } } } public static Method getBoxMethod(Type type) { int sortType = type.getSort(); assert (sortType >= 0 && sortType < SORT_MAP.length) : "Unexpected JavaScriptHostInfo.get index - " + sortType; return SORT_MAP[sortType]; } } /** * Oracle for info regarding {@link JavaScriptHost}. */ private static class JavaScriptHostInfo { /** * The {@link JavaScriptHost} type. */ public static final Type TYPE = Type.getType(JavaScriptHost.class); /** * The parameter signature of {@link JavaScriptHost}'s invoke* methods, in * classes. */ private static final Class<?>[] INVOKE_NATIVE_PARAM_CLASSES = new Class[] { String.class, Object.class, Class[].class, Object[].class, }; /** * The parameter signature of {@link JavaScriptHost}'s invoke* methods, in * types. */ private static final Type[] INVOKE_NATIVE_PARAM_TYPES; /** * A map of Type.sort() to JavaScriptHostInfo. */ private static final JavaScriptHostInfo[] SORT_MAP = new JavaScriptHostInfo[11]; static { INVOKE_NATIVE_PARAM_TYPES = new Type[INVOKE_NATIVE_PARAM_CLASSES.length]; for (int i = 0; i < INVOKE_NATIVE_PARAM_TYPES.length; ++i) { INVOKE_NATIVE_PARAM_TYPES[i] = Type.getType(INVOKE_NATIVE_PARAM_CLASSES[i]); } Class<?>[] primitives = { void.class, boolean.class, byte.class, char.class, short.class, int.class, long.class, float.class, double.class }; for (Class<?> c : primitives) { Type type = Type.getType(c); String typeName = type.getClassName(); String firstChar = typeName.substring(0, 1).toUpperCase(Locale.ROOT); typeName = firstChar + typeName.substring(1); SORT_MAP[type.getSort()] = new JavaScriptHostInfo(type, "invokeNative" + typeName); } JavaScriptHostInfo objectType = new JavaScriptHostInfo(Type.getType(Object.class), "invokeNativeObject", true); SORT_MAP[Type.ARRAY] = objectType; SORT_MAP[Type.OBJECT] = objectType; assert noNulls(SORT_MAP) : "Did not fully fill in JavaScriptHostInfo.SORT_MAP"; } public static JavaScriptHostInfo get(int sortType) { assert (sortType >= 0 && sortType < SORT_MAP.length) : "Unexpected JavaScriptHostInfo.get index - " + sortType; return SORT_MAP[sortType]; } /** * Validate our model against the real JavaScriptHost class. */ private static boolean matchesRealMethod(String methodName, Type returnType) { try { java.lang.reflect.Method method = JavaScriptHost.class.getDeclaredMethod(methodName, INVOKE_NATIVE_PARAM_CLASSES); assert (method.getModifiers() & Modifier.STATIC) != 0 : "Was expecting method '" + method + "' to be static"; Type realReturnType = Type.getType(method.getReturnType()); return realReturnType.getDescriptor().equals(returnType.getDescriptor()); } catch (SecurityException e) { } catch (NoSuchMethodException e) { } return false; } private static boolean noNulls(Object[] array) { for (Object element : array) { if (element == null) { return false; } } return true; } private final Method method; private final boolean requiresCast; private JavaScriptHostInfo(Type returnType, String methodName) { this(returnType, methodName, false); } private JavaScriptHostInfo(Type returnType, String methodName, boolean requiresCast) { this.requiresCast = requiresCast; this.method = new Method(methodName, returnType, INVOKE_NATIVE_PARAM_TYPES); assert matchesRealMethod(methodName, returnType) : "JavaScriptHostInfo for '" + this + "' does not match real method"; } public Method getMethod() { return method; } public boolean requiresCast() { return requiresCast; } @Override public String toString() { return method.toString(); } } /** * Rewrites native Java methods to dispatch as JSNI. */ private class MyMethodAdapter extends GeneratorAdapter { private String descriptor; private boolean isStatic; private String name; public MyMethodAdapter(MethodVisitor mv, int access, String name, String desc) { super(Opcodes.ASM6, mv, access, name, desc); this.descriptor = desc; this.name = name; isStatic = (access & Opcodes.ACC_STATIC) != 0; } /** * Replacement for {@link GeneratorAdapter#box(Type)}, which always calls, * for example, {@code new Boolean} instead of using * {@link Boolean#valueOf(boolean)}. */ @Override public void box(Type type) { Method method = Boxing.getBoxMethod(type); if (method != null) { invokeStatic(method.getReturnType(), method); } } /** * Does all of the work necessary to do the dispatch to the appropriate * variant of {@link JavaScriptHost#invokeNativeVoid * JavaScriptHost.invokeNative*}. And example output: * * <pre> * return JavaScriptHost.invokeNativeInt( * "@com.google.gwt.sample.hello.client.Hello::echo(I)", null, * new Class[] {int.class,}, new Object[] {x,}); * </pre> */ @Override public void visitCode() { super.visitCode(); /* * If you modify the generated code, you must recompute the stack size in * visitEnd(). */ // First argument - JSNI signature String jsniTarget = getJsniSignature(name, descriptor); visitLdcInsn(jsniTarget); // Stack is at 1 // Second argument - target; "null" if static, otherwise "this". if (isStatic) { visitInsn(Opcodes.ACONST_NULL); } else { loadThis(); } // Stack is at 2 // Third argument - a Class[] describing the types of this method loadClassArray(); // Stack is at 3; reaches 6 internally // Fourth argument - all the arguments boxed into an Object[] loadArgArray(); // Stack is at 4; reaches 7 or 8 internally (long/double takes 2) // Invoke the matching JavaScriptHost.invokeNative* method Type returnType = Type.getReturnType(descriptor); JavaScriptHostInfo info = JavaScriptHostInfo.get(returnType.getSort()); invokeStatic(JavaScriptHostInfo.TYPE, info.getMethod()); // Stack is at 1 if (info.requiresCast()) { checkCast(returnType); } returnValue(); // Stack is at 0 } @Override public void visitEnd() { // Force code to be visited; required since this was a native method. visitCode(); /* * For speed, we don't ask ASM to COMPUTE_MAXS. We manually calculated a * max depth of 8. * * Also, when tobyr tried getting ASM to compute the correct stack size, * ASM seemed to compute the wrong value for reasons we don't understand. */ int maxStack = 8; int maxLocals = 0; // Computed by GeneratorAdapter superclass. super.visitMaxs(maxStack, maxLocals); super.visitEnd(); } private void loadClassArray() { Type[] argTypes = Type.getArgumentTypes(descriptor); push(argTypes.length); newArray(CLASS_TYPE); // Stack is at 3 for (int i = 0; i < argTypes.length; ++i) { dup(); push(i); push(argTypes[i]); arrayStore(CLASS_TYPE); } } } private static final Type BOOLEAN_TYPE = Type.getObjectType("java/lang/Boolean"); private static final Type BYTE_TYPE = Type.getObjectType("java/lang/Byte"); private static final Type CHARACTER_TYPE = Type.getObjectType("java/lang/Character"); private static final Type CLASS_TYPE = Type.getObjectType("java/lang/Class"); private static final Type DOUBLE_TYPE = Type.getObjectType("java/lang/Double"); private static final Type FLOAT_TYPE = Type.getObjectType("java/lang/Float"); private static final Type INTEGER_TYPE = Type.getObjectType("java/lang/Integer"); private static final Type LONG_TYPE = Type.getObjectType("java/lang/Long"); private static final Type SHORT_TYPE = Type.getObjectType("java/lang/Short"); private static final Type VOID_TYPE = Type.getObjectType("java/lang/Void"); /** * The internal name of the class we're operating on. */ private String classDesc; private Map<String, String> anonymousClassMap; public RewriteJsniMethods(ClassVisitor v, Map<String, String> anonymousClassMap) { super(Opcodes.ASM6, v); this.anonymousClassMap = anonymousClassMap; } @Override public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { this.classDesc = name; super.visit(version, access, name, signature, superName, interfaces); } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { boolean isNative = (access & Opcodes.ACC_NATIVE) != 0; access &= ~Opcodes.ACC_NATIVE; MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); if (isNative) { mv = new MyMethodAdapter(mv, access, name, desc); } return mv; } /** * Returns the JSNI signature describing the method. * * @param name the name of the method; for example {@code "echo"} * @param descriptor the descriptor for the method; for example {@code "(I)I"} * @return the JSNI signature for the method; for example, {@code * "@com.google.gwt.sample.hello.client.Hello::echo(I)"} */ private String getJsniSignature(String name, String descriptor) { int argsIndexBegin = descriptor.indexOf('('); int argsIndexEnd = descriptor.indexOf(')'); assert argsIndexBegin != -1 && argsIndexEnd != -1 && argsIndexBegin < argsIndexEnd : "Could not find the arguments in the descriptor, " + descriptor; String argsDescriptor = descriptor.substring(argsIndexBegin, argsIndexEnd + 1); String classDescriptor = InternalName.toBinaryName(classDesc); String newDescriptor = anonymousClassMap.get(classDesc); if (newDescriptor != null) { classDescriptor = InternalName.toBinaryName(newDescriptor); } // Always use binary names for JSNI method names return "@" + classDescriptor + "::" + name + argsDescriptor; } }