Java tutorial
/* * Copyright 2009 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.core.ext.typeinfo.JClassType; import com.google.gwt.core.ext.typeinfo.TypeOracle; import com.google.gwt.dev.shell.rewrite.HostedModeClassRewriter.SingleJsoImplData; import com.google.gwt.dev.util.collect.Maps; import com.google.gwt.dev.util.collect.Sets; 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.Method; import java.util.Collections; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; /** * Effects the renaming of {@code @SingleJsoImpl} methods from their original * name to their mangled name. Let us call the original method an "unmangled * method" and the new method a "mangled method". There are three steps in this * process: * <ol> * <li>Within {@code @SingleJsoImpl} interfaces rename all unmangled methods to * become mangled methods.</li> * <li>Within non-JSO classes containing a concrete implementation of an * unmangled method, add a mangled method which is implemented as a simple * trampoline to the unmangled method. (We don't do this in JSO classes here * because the one-and-only trampoline lives in JavaScriptObject$ and is emitted * in {@link WriteJsoImpl}). * <li>Update all call sites targeting unmangled methods to target mangled * methods instead, provided the caller is binding to the interface rather than * a concrete type.</li> * </ol> */ public class RewriteSingleJsoImplDispatches extends ClassVisitor { private class MyMethodVisitor extends MethodVisitor { public MyMethodVisitor(MethodVisitor mv) { super(Opcodes.ASM6, mv); } /* * Implements objective #3: updates call sites to unmangled methods. */ @Override public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean dintf) { if (opcode == Opcodes.INVOKEINTERFACE) { if (jsoData.getSingleJsoIntfTypes().contains(owner)) { // Simple case; referring directly to a SingleJso interface. name = owner.replace('/', '_') + "_" + name; assert jsoData.getMangledNames().contains(name) : "Missing " + name; } else { /* * Might be referring to a subtype of a SingleJso interface: * * interface IA { void foo() } * * interface JA extends JSO implements IA; * * interface IB extends IA {} * * void bar() { ((IB) object).foo(); } */ outer: for (String intf : computeAllInterfaces(owner)) { if (jsoData.getSingleJsoIntfTypes().contains(intf)) { /* * Check that it really should be mangled and is not a reference * to a method defined in a non-singleJso super-interface. If * there are two super-interfaces that define methods with * identical names and descriptors, the choice of implementation * is undefined. */ String maybeMangled = intf.replace('/', '_') + "_" + name; List<Method> methods = jsoData.getImplementations(maybeMangled); if (methods != null) { for (Method method : methods) { /* * Found a method with the right name, but we need to check * the parameters and the return type. In order to do this, * we'll look at the arguments and return type of the target * method, removing the first argument, which is the instance. */ assert method.getArgumentTypes().length >= 1; Type[] argumentTypes = new Type[method.getArgumentTypes().length - 1]; System.arraycopy(method.getArgumentTypes(), 1, argumentTypes, 0, argumentTypes.length); String maybeDescriptor = Type.getMethodDescriptor(method.getReturnType(), argumentTypes); if (maybeDescriptor.equals(desc)) { name = maybeMangled; break outer; } } } } } } } super.visitMethodInsn(opcode, owner, name, desc, dintf); } } private String currentTypeName; private final Set<String> implementedMethods = new HashSet<String>(); private boolean inSingleJsoImplInterfaceType; private Map<String, Set<String>> intfNamesToAllInterfaces = Maps.create(); private final SingleJsoImplData jsoData; private final TypeOracle typeOracle; public RewriteSingleJsoImplDispatches(ClassVisitor v, TypeOracle typeOracle, SingleJsoImplData jsoData) { super(Opcodes.ASM6, v); this.typeOracle = typeOracle; this.jsoData = jsoData; } @Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { assert currentTypeName == null; super.visit(version, access, name, signature, superName, interfaces); /* * This visitor would mangle JSO$ since it acts as a roll-up of all * SingleJso types and the result would be repeated method definitions due * to the trampoline methods this visitor would create. */ if (name.equals(HostedModeClassRewriter.JAVASCRIPTOBJECT_IMPL_DESC)) { return; } currentTypeName = name; inSingleJsoImplInterfaceType = jsoData.getSingleJsoIntfTypes().contains(name); /* * Implements objective #2: non-JSO types that implement a SingleJsoImpl * interface don't have their original instance methods altered. Instead, we * add trampoline methods with mangled names that simply call over to the * original methods. */ if (interfaces != null && (access & Opcodes.ACC_INTERFACE) == 0) { Set<String> toStub = computeAllInterfaces(interfaces); toStub.retainAll(jsoData.getSingleJsoIntfTypes()); for (String stubIntr : toStub) { writeTrampoline(stubIntr); } } } @Override public void visitEnd() { /* * Add any missing methods that are defined by a super-interface, but that * may be referenced via a more specific interface. */ if (inSingleJsoImplInterfaceType) { for (String mangledName : toImplement(currentTypeName)) { for (Method method : jsoData.getDeclarations(mangledName)) { writeEmptyMethod(mangledName, method); } } } super.visitEnd(); } @Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { /* * Implements objective #2: Rename unmangled methods in a @SingleJsoImpl * into mangled methods (except for clinit, LOL). */ if (inSingleJsoImplInterfaceType && !"<clinit>".equals(name)) { name = currentTypeName.replace('/', '_') + "_" + name; implementedMethods.add(name); } MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); if (mv == null) { return null; } return new MyMethodVisitor(mv); } private Set<String> computeAllInterfaces(String intfName) { Set<String> toReturn = intfNamesToAllInterfaces.get(intfName); if (toReturn != null) { return toReturn; } toReturn = Sets.create(); List<JClassType> q = new LinkedList<JClassType>(); JClassType intf = typeOracle.findType(intfName.replace('/', '.').replace('$', '.')); /* * If the interface's compilation unit wasn't retained due to an error, then * it won't be available in the typeOracle for us to rewrite */ if (intf != null) { q.add(intf); } while (!q.isEmpty()) { intf = q.remove(0); String resourceName = getResourceName(intf); if (!toReturn.contains(resourceName)) { toReturn = Sets.add(toReturn, resourceName); Collections.addAll(q, intf.getImplementedInterfaces()); } } intfNamesToAllInterfaces = Maps.put(intfNamesToAllInterfaces, intfName, toReturn); return toReturn; } private Set<String> computeAllInterfaces(String[] interfaces) { Set<String> toReturn = new HashSet<String>(); for (String intfName : interfaces) { toReturn.addAll(computeAllInterfaces(intfName)); } return toReturn; } private String getResourceName(JClassType type) { if (type.getEnclosingType() != null) { return getResourceName(type.getEnclosingType()) + "$" + type.getSimpleSourceName(); } return type.getQualifiedSourceName().replace('.', '/'); } /** * Given a resource name of a class, find all mangled method names that must * be implemented. */ private SortedSet<String> toImplement(String typeName) { String name = typeName.replace('/', '_'); String prefix = name + "_"; String suffix = name + "`"; SortedSet<String> toReturn = new TreeSet<String>(); for (String mangledName : jsoData.getMangledNames().subSet(prefix, suffix)) { if (!implementedMethods.contains(mangledName)) { toReturn.add(mangledName); } } return toReturn; } private void writeEmptyMethod(String mangledMethodName, Method declMethod) { MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, mangledMethodName, declMethod.getDescriptor(), null, null); mv.visitEnd(); } /** * For regular Java objects that implement a SingleJsoImpl interface, write * instance trampoline dispatchers for mangled method names to the * implementing method. */ private void writeTrampoline(String stubIntr) { /* * This is almost the same kind of trampoline as the ones generated in * WriteJsoImpl, however there are enough small differences between the * semantics of the dispatches that would make a common implementation far * more awkward than the duplication of code. */ for (String mangledName : toImplement(stubIntr)) { for (Method method : jsoData.getDeclarations(mangledName)) { Method toCall = new Method(method.getName(), method.getDescriptor()); // Must not be final MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, mangledName, method.getDescriptor(), null, null); if (mv != null) { mv.visitCode(); /* * It just so happens that the stack and local variable sizes are the * same, but they're kept distinct to aid in clarity should the * dispatch logic change. * * These start at 1 because we need to load "this" onto the stack */ int var = 1; int size = 1; // load this mv.visitVarInsn(Opcodes.ALOAD, 0); // then the rest of the arguments for (Type t : toCall.getArgumentTypes()) { size += t.getSize(); mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), var); var += t.getSize(); } // Make sure there's enough room for the return value size = Math.max(size, toCall.getReturnType().getSize()); mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, currentTypeName, toCall.getName(), toCall.getDescriptor(), false); mv.visitInsn(toCall.getReturnType().getOpcode(Opcodes.IRETURN)); mv.visitMaxs(size, var); mv.visitEnd(); } } } } }