Adding @ModifyArg and @Redirect annotations, example code to follow

This commit is contained in:
Mumfrey committed 2015-01-11 22:44:45 +00:00
1 parent 5e283e8039
commit adfeb07297
23 files changed
+1158 -257

No files matched your search

@@ -325,9 +325,16 @@ class AnnotatedMixins {
if (this.shouldRemap(mixinClass, inject)) {
mixinClass.registerInjector(method, inject);
List<AnnotationMirror> annotationValue = MirrorUtils.<List<AnnotationMirror>>getAnnotationValue(inject, "at");
for (AnnotationMirror at : annotationValue) {
mixinClass.registerInjectionPoint(at);
Object ats = MirrorUtils.getAnnotationValue(inject, "at");
if (ats instanceof List) {
@SuppressWarnings("unchecked")
List<AnnotationMirror> annotationValue = (List<AnnotationMirror>)ats;
for (AnnotationMirror at : annotationValue) {
mixinClass.registerInjectionPoint(at);
}
} else if (ats instanceof AnnotationMirror) {
mixinClass.registerInjectionPoint((AnnotationMirror)ats);
}
}
}
@@ -24,6 +24,7 @@
*/
package org.spongepowered.tools.obfuscation;
import java.lang.annotation.Annotation;
import java.util.Set;
import javax.annotation.processing.RoundEnvironment;
@@ -38,15 +39,21 @@ import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.tools.MirrorUtils;
/**
* Annotation processor which finds {@link Inject} and {@link At} annotations in mixin classes and generates SRG mappings
*/
@SupportedSourceVersion(SourceVersion.RELEASE_6)
@SupportedAnnotationTypes({ "org.spongepowered.asm.mixin.injection.Inject", "org.spongepowered.asm.mixin.injection.At" })
@SupportedAnnotationTypes({
"org.spongepowered.asm.mixin.injection.Inject",
"org.spongepowered.asm.mixin.injection.ModifyArg",
"org.spongepowered.asm.mixin.injection.Redirect",
"org.spongepowered.asm.mixin.injection.At"
})
@SupportedOptions({ "reobfSrgFile", "outSrgFile" })
public class InjectionObfuscationProcessor extends MixinProcessor {
@@ -60,7 +67,9 @@ public class InjectionObfuscationProcessor extends MixinProcessor {
}
this.processMixins(roundEnv);
this.processInjectors(roundEnv);
this.processInjectors(roundEnv, Inject.class);
this.processInjectors(roundEnv, ModifyArg.class);
this.processInjectors(roundEnv, Redirect.class);
try {
this.mixins.writeRefs();
@@ -74,20 +83,21 @@ public class InjectionObfuscationProcessor extends MixinProcessor {
/**
* Searches for {@link Inject} annotations and registers them with their parent mixins
*/
private void processInjectors(RoundEnvironment roundEnv) {
for (Element elem : roundEnv.getElementsAnnotatedWith(Inject.class)) {
private void processInjectors(RoundEnvironment roundEnv, Class<? extends Annotation> injectorClass) {
for (Element elem : roundEnv.getElementsAnnotatedWith(injectorClass)) {
Element parent = elem.getEnclosingElement();
if (!(parent instanceof TypeElement)) {
throw new IllegalStateException("@Shadow element has unexpected parent with type " + MirrorUtils.getElementType(parent));
throw new IllegalStateException("@" + injectorClass.getSimpleName() + " element has unexpected parent with type "
+ MirrorUtils.getElementType(parent));
}
AnnotationMirror inject = MirrorUtils.getAnnotation(elem, Inject.class);
AnnotationMirror inject = MirrorUtils.getAnnotation(elem, injectorClass);
if (elem.getKind() == ElementKind.METHOD) {
this.mixins.registerInjector((TypeElement)parent, (ExecutableElement)elem, inject);
} else {
this.processingEnv.getMessager().printMessage(Kind.WARNING,
"Found an @Inject annotation on an element which is not a method: " + elem.toString());
"Found an @" + injectorClass.getSimpleName() + " annotation on an element which is not a method: " + elem.toString());
}
}
}
@@ -176,6 +176,7 @@ public class MixinTweaker implements ITweaker {
Attributes manifestAttributes = jarFile.getManifest().getMainAttributes();
return manifestAttributes.getValue(key);
} catch (IOException ex) {
// be quiet checkstyle
} finally {
if (jarFile != null) {
try {
@@ -290,7 +290,8 @@ public abstract class InjectionPoint {
/**
* Parse and instantiate an InjectionPoint from the supplied information. Returns null if an InjectionPoint could not be created.
*/
public static InjectionPoint parse(MixinData mixin, String at, At.Shift shift, int by, List<String> args, String target, int ordinal, int opcode) {
public static InjectionPoint parse(MixinData mixin, String at, At.Shift shift, int by,
List<String> args, String target, int ordinal, int opcode) {
InjectionPointData data = new InjectionPointData(mixin, args, target, ordinal, opcode);
InjectionPoint point = null;
@@ -0,0 +1,67 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Specifies that this mixin method should inject an argument modifier to itself in the target method(s) identified by {@link #method}.
*/
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyArg {
/**
* String representation of a {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target method.
*/
public String method();
/**
* An {@link At} annotation which describes the {@link InjectionPoint} in the target method. The specified {@link InjectionPoint} <em>must only
* </em> return nodes of type {@link org.objectweb.asm.tree.MethodInsnNode} and an exception will be thrown if this is not the case.
*/
public At at();
/**
* <p>Gets the argument index on the target to set. It is not necessary to set this value if there is only one argument of the modifier type in
* the hooked method's signature. For example if the target method accepts a boolean, an integer and a String, and the modifier method accepts
* and returns an integer, then the integer parameter will be automatically selected.</p>
*
* <p>The index is zero-based.</p>
*/
public int index() default -1;
/**
* By default, the annotation processor will attempt to locate an obfuscation mapping for all {@link ModifyArg} methods since it is anticipated
* that in general the target of a {@link ModifyArg} annotation will be an obfuscated method in the target class. However since it is possible to
* also apply mixins to non-obfuscated targets (or non-obfuscated methods in obfuscated targets, such as methods added by Forge) it may be
* necessary to suppress the compiler error which would otherwise be generated. Setting this value to <em>false</em> will cause the annotation
* processor to skip this annotation when attempting to build the obfuscation table for the mixin.
*/
public boolean remap() default true;
}
@@ -0,0 +1,58 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Specifies that this mixin method should redirect the specified {@link #method} call to the method decorated with this annotation.
*/
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Redirect {
/**
* String representation of a {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo MemberInfo} which identifies the target method.
*/
public String method();
/**
* An {@link At} annotation which describes the {@link InjectionPoint} in the target method. The specified {@link InjectionPoint} <em>must only
* </em> return nodes of type {@link org.objectweb.asm.tree.MethodInsnNode} and an exception will be thrown if this is not the case.
*/
public At at();
/**
* By default, the annotation processor will attempt to locate an obfuscation mapping for all {@link ModifyArg} methods since it is anticipated
* that in general the target of a {@link ModifyArg} annotation will be an obfuscated method in the target class. However since it is possible to
* also apply mixins to non-obfuscated targets (or non-obfuscated methods in obfuscated targets, such as methods added by Forge) it may be
* necessary to suppress the compiler error which would otherwise be generated. Setting this value to <em>false</em> will cause the annotation
* processor to skip this annotation when attempting to build the obfuscation table for the mixin.
*/
public boolean remap() default true;
}
@@ -107,7 +107,7 @@ public class CallbackInfo implements Cancellable {
return CallbackInfo.class.getName();
}
static String getCallInfoClassName(Type returnType) {
public static String getCallInfoClassName(Type returnType) {
return (returnType.equals(Type.VOID_TYPE) ? CallbackInfo.class.getName() : CallbackInfoReturnable.class.getName()).replace('.', '/');
}
@@ -24,112 +24,33 @@
*/
package org.spongepowered.asm.mixin.injection.callback;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.*;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.TypeInsnNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.points.BeforeReturn;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.util.ASMHelper;
import org.spongepowered.asm.util.Locals;
/**
* This class is responsible for generating the bytecode for injected callbacks
*/
public class CallbackInjector {
private static final String CTOR = "<init>";
/**
* Information about the current injection target, mainly just convenience rather than passing a bunch of values around
*/
class Target {
/**
* Target method
*/
final MethodNode method;
/**
* Method arguments
*/
final Type[] arguments;
/**
* Return type computed from the method descriptor
*/
final Type returnType;
/**
* Method's (original) MAXS
*/
// CHECKSTYLE:OFF
final int MAXS;
// CHECKSTYLE:ON
/**
* Callback method descriptor based on this target
*/
final String callbackDescriptor;
/**
* Callback info class
*/
final String callbackInfoClass;
/**
* Make a new Target for the supplied method
*/
Target(MethodNode method) {
this.method = method;
this.arguments = Type.getArgumentTypes(method.desc);
this.returnType = Type.getReturnType(method.desc);
this.MAXS = method.maxStack;
this.callbackInfoClass = CallbackInfo.getCallInfoClassName(this.returnType);
this.callbackDescriptor = String.format("(%sL%s;)V", method.desc.substring(1, method.desc.indexOf(')')), this.callbackInfoClass);
}
/**
* Get the callback descriptor
*/
String getCallbackDescriptor(final boolean captureLocals, final Type[] locals, Type[] argumentTypes, int startIndex) {
if (!captureLocals) {
return this.callbackDescriptor;
}
String descriptor = this.callbackDescriptor.substring(0, this.callbackDescriptor.indexOf(')'));
for (int l = startIndex; l < locals.length; l++) {
if (locals[l] != null) {
descriptor += locals[l].getDescriptor();
}
}
return descriptor + ")V";
}
}
/**
* True if the callback method is static
*/
private final boolean isStatic;
/**
* Class node
*/
private final ClassNode classNode;
/**
* Callback method
*/
private final MethodNode methodNode;
public class CallbackInjector extends Injector {
/**
* True if cancellable
@@ -141,75 +62,26 @@ public class CallbackInjector {
*/
private final boolean captureLocals;
/**
* Make a new CallbackInjector for the supplied InjectionInfo
*/
public CallbackInjector(InjectionInfo info) {
this(info.getClassNode(), info.getMethod(), info.getCancellable(), info.getCaptureLocals());
}
/**
* Make a new CallbackInjector with the supplied args
*/
public CallbackInjector(ClassNode classNode, MethodNode methodNode, boolean cancellable, boolean captureLocals) {
this.classNode = classNode;
this.methodNode = methodNode;
public CallbackInjector(InjectionInfo info, boolean cancellable, boolean captureLocals) {
super(info);
this.cancellable = cancellable;
this.captureLocals = captureLocals;
this.isStatic = ASMHelper.methodIsStatic(methodNode);
}
/**
* Inject into the specified method at the specified injection points
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.callback.BytecodeInjector#sanityCheck(org.spongepowered.asm.mixin.injection.callback.Target,
* java.util.List)
*/
public void injectInto(MethodNode into, List<InjectionPoint> injectionPoints) {
this.sanityCheck(into, injectionPoints);
for (AbstractInsnNode targetNode : this.findTargetNodes(into, injectionPoints)) {
Type[] localTypes = null;
if (this.captureLocals) {
LocalVariableNode[] locals = Locals.getLocalsAt(this.classNode, into, targetNode);
if (locals != null) {
localTypes = new Type[locals.length];
for (int l = 0; l < locals.length; l++) {
if (locals[l] != null) {
localTypes[l] = Type.getType(locals[l].desc);
}
}
}
}
Target target = new Target(into);
this.inject(target, targetNode, localTypes);
}
}
private Set<AbstractInsnNode> findTargetNodes(MethodNode into, List<InjectionPoint> injectionPoints) {
Set<AbstractInsnNode> targetNodes = new HashSet<AbstractInsnNode>();
// Defensive objects, so that injectionPoint instances can't modify our working copies
ReadOnlyInsnList insns = new ReadOnlyInsnList(into.instructions);
Collection<AbstractInsnNode> nodes = new ArrayList<AbstractInsnNode>(32);
for (InjectionPoint injectionPoint : injectionPoints) {
nodes.clear();
if (injectionPoint.find(into.desc, insns, nodes)) {
targetNodes.addAll(nodes);
}
}
insns.dispose();
return targetNodes;
}
private void sanityCheck(MethodNode target, List<InjectionPoint> injectionPoints) {
if (ASMHelper.methodIsStatic(target) != this.isStatic) {
@Override
protected void sanityCheck(Target target, List<InjectionPoint> injectionPoints) {
if (ASMHelper.methodIsStatic(target.method) != this.isStatic) {
throw new InvalidInjectionException("'static' modifier of callback method does not match target in " + this.methodNode.name);
}
if (CallbackInjector.CTOR.equals(target.name)) {
if (Injector.CTOR.equals(target.method.name)) {
for (InjectionPoint injectionPoint : injectionPoints) {
if (!injectionPoint.getClass().equals(BeforeReturn.class)) {
throw new InvalidInjectionException("Found injection point type " + injectionPoint.getClass().getSimpleName()
@@ -219,10 +91,34 @@ public class CallbackInjector {
}
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.callback.BytecodeInjector#inject(org.spongepowered.asm.mixin.injection.callback.Target,
* org.objectweb.asm.tree.AbstractInsnNode)
*/
@Override
protected void inject(Target target, AbstractInsnNode node) {
Type[] localTypes = null;
if (this.captureLocals) {
LocalVariableNode[] locals = Locals.getLocalsAt(this.classNode, target.method, node);
if (locals != null) {
localTypes = new Type[locals.length];
for (int l = 0; l < locals.length; l++) {
if (locals[l] != null) {
localTypes[l] = Type.getType(locals[l].desc);
}
}
}
}
this.inject(target, node, localTypes);
}
/**
* Generate the actual bytecode
*/
private void inject(Target target, final AbstractInsnNode targetNode, final Type[] locals) {
private void inject(Target target, final AbstractInsnNode node, final Type[] locals) {
// Calculate the initial frame size based on the target method's arguments
int initialFrameSize = ASMHelper.getFirstNonArgLocalIndex(target.arguments, !this.isStatic);
@@ -234,7 +130,7 @@ public class CallbackInjector {
// If it doesn't match, then cry
if (!callbackDescriptor.equals(this.methodNode.desc)) {
throw new InvalidInjectionException("Invalid descriptor on callback method, expected " + callbackDescriptor);
throw new InvalidInjectionException("Invalid descriptor on callback: expected " + callbackDescriptor + " found " + this.methodNode.desc);
}
// These two variables keep track of the (additional) stack size required for the two actions we're going to be injecting insns to perform,
@@ -256,7 +152,7 @@ public class CallbackInjector {
// If this is a ReturnEventInfo AND we are right before a RETURN opcode (so we can expect the *original* return value to be on the stack,
// then we dup the return value into a local var so we can push it later when we invoke the ReturnEventInfo ctor
if (targetNode instanceof InsnNode && targetNode.getOpcode() >= Opcodes.IRETURN && targetNode.getOpcode() < Opcodes.RETURN) {
if (node instanceof InsnNode && node.getOpcode() >= Opcodes.IRETURN && node.getOpcode() < Opcodes.RETURN) {
pushReturnValue = true;
insns.add(new InsnNode(Opcodes.DUP));
insns.add(new VarInsnNode(target.returnType.getOpcode(Opcodes.ISTORE), marshallVar));
@@ -292,12 +188,12 @@ public class CallbackInjector {
if (this.cancellable) {
// Inject the if (e.isCancelled()) return e.getReturnValue();
this.injectCancellationCode(target, insns, targetNode, marshallVar);
this.injectCancellationCode(target, insns, node, marshallVar);
}
// Inject our generated code into the method
target.method.instructions.insertBefore(targetNode, insns);
target.method.maxStack = Math.max(target.method.maxStack, Math.max(target.MAXS + ctorMAXS, target.MAXS + invokeMAXS));
target.method.instructions.insertBefore(node, insns);
target.method.maxStack = Math.max(target.method.maxStack, Math.max(target.maxStack + ctorMAXS, target.maxStack + invokeMAXS));
}
protected int invokeCallbackInfoCtor(Target target, InsnList insns, boolean cancellable, boolean pushReturnValue, int marshallVar) {
@@ -311,10 +207,10 @@ public class CallbackInjector {
if (pushReturnValue) {
insns.add(new VarInsnNode(target.returnType.getOpcode(Opcodes.ILOAD), marshallVar));
insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL,
target.callbackInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(target.returnType), false));
target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(target.returnType), false));
} else {
insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL,
target.callbackInfoClass, CallbackInjector.CTOR, CallbackInfo.getConstructorDescriptor(), false));
target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(), false));
}
return ctorMAXS;
@@ -323,11 +219,12 @@ public class CallbackInjector {
/**
* if (e.isCancelled()) return e.getReturnValue();
*
* @param target
* @param insns
* @param targetNode
* @param node
* @param marshallVar
*/
protected void injectCancellationCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int marshallVar) {
protected void injectCancellationCode(Target target, final InsnList insns, final AbstractInsnNode node, int marshallVar) {
insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar));
insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callbackInfoClass, CallbackInfo.getIsCancelledMethodName(),
CallbackInfo.getIsCancelledMethodSig(), false));
@@ -336,7 +233,7 @@ public class CallbackInjector {
insns.add(new JumpInsnNode(Opcodes.IFEQ, notCancelled));
// If this is a void method, just injects a RETURN opcode, otherwise we need to get the return value from the EventInfo
this.injectReturnCode(target, insns, targetNode, marshallVar);
this.injectReturnCode(target, insns, node, marshallVar);
insns.add(notCancelled);
}
@@ -344,11 +241,12 @@ public class CallbackInjector {
/**
* Inject the appropriate return code for the method type
*
* @param target
* @param insns
* @param targetNode
* @param node
* @param marshallVar
*/
protected void injectReturnCode(Target target, final InsnList insns, final AbstractInsnNode targetNode, int marshallVar) {
protected void injectReturnCode(Target target, final InsnList insns, final AbstractInsnNode node, int marshallVar) {
if (target.returnType.equals(Type.VOID_TYPE)) {
// Void method, so just return void
insns.add(new InsnNode(Opcodes.RETURN));
@@ -0,0 +1,121 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.code;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.util.ASMHelper;
import com.google.common.base.Joiner;
/**
* Base class for bytecode injectors
*/
public abstract class Injector {
protected static final String CTOR = "<init>";
/**
* Class node
*/
protected final ClassNode classNode;
/**
* Callback method
*/
protected final MethodNode methodNode;
/**
* True if the callback method is static
*/
protected final boolean isStatic;
/**
* Make a new CallbackInjector for the supplied InjectionInfo
*/
public Injector(InjectionInfo info) {
this(info.getClassNode(), info.getMethod());
}
/**
* Make a new CallbackInjector with the supplied args
*/
private Injector(ClassNode classNode, MethodNode methodNode) {
this.classNode = classNode;
this.methodNode = methodNode;
this.isStatic = ASMHelper.methodIsStatic(this.methodNode);
}
/**
* Inject into the specified method at the specified injection points
*/
public final void injectInto(Target target, List<InjectionPoint> injectionPoints) {
this.sanityCheck(target, injectionPoints);
for (AbstractInsnNode node : this.findTargetNodes(target.method, injectionPoints)) {
this.inject(target, node);
}
}
protected Set<AbstractInsnNode> findTargetNodes(MethodNode into, List<InjectionPoint> injectionPoints) {
Set<AbstractInsnNode> targetNodes = new HashSet<AbstractInsnNode>();
// Defensive objects, so that injectionPoint instances can't modify our working copies
ReadOnlyInsnList insns = new ReadOnlyInsnList(into.instructions);
Collection<AbstractInsnNode> nodes = new ArrayList<AbstractInsnNode>(32);
for (InjectionPoint injectionPoint : injectionPoints) {
nodes.clear();
if (injectionPoint.find(into.desc, insns, nodes)) {
targetNodes.addAll(nodes);
}
}
insns.dispose();
return targetNodes;
}
protected void sanityCheck(Target target, List<InjectionPoint> injectionPoints) {
// stub for subclasses
}
protected abstract void inject(Target target, AbstractInsnNode node);
protected static String printArgs(Type[] args) {
return "(" + Joiner.on("").join(args) + ")";
}
}
@@ -22,7 +22,7 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.callback;
package org.spongepowered.asm.mixin.injection.code;
import java.util.ListIterator;
@@ -33,7 +33,7 @@ import org.objectweb.asm.tree.InsnList;
* Read-only wrapper for InsnList, defensively passed to InjectionPoint instances so that custom InjectionPoint implementations cannot modify the insn
* list whilst inspecting it.
*/
public class ReadOnlyInsnList extends InsnList {
class ReadOnlyInsnList extends InsnList {
private InsnList insnList;
@@ -0,0 +1,149 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke;
import java.util.List;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.util.ASMHelper;
public abstract class InvokeInjector extends Injector {
/**
* Arguments of the handler method
*/
protected final Type[] methodArgs;
/**
* Return type of the handler method
*/
protected final Type returnType;
protected final String annotationType;
public InvokeInjector(InjectionInfo info, String annotationType) {
super(info);
this.methodArgs = Type.getArgumentTypes(this.methodNode.desc);
this.returnType = Type.getReturnType(this.methodNode.desc);
this.annotationType = annotationType;
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.callback.BytecodeInjector#sanityCheck(org.spongepowered.asm.mixin.injection.callback.Target,
* java.util.List)
*/
@Override
protected void sanityCheck(Target target, List<InjectionPoint> injectionPoints) {
if (ASMHelper.methodIsStatic(target.method) != this.isStatic) {
throw new InvalidInjectionException("'static' modifier of callback method does not match target in " + this.methodNode.name);
}
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.callback.BytecodeInjector#inject(org.spongepowered.asm.mixin.injection.callback.Target,
* org.objectweb.asm.tree.AbstractInsnNode)
*/
@Override
protected void inject(Target target, AbstractInsnNode node) {
if (!(node instanceof MethodInsnNode)) {
throw new InvalidInjectionException(this.annotationType + " annotation is targetting a non-method insn in " + target
+ " in " + this.classNode.name);
}
this.inject(target, (MethodInsnNode)node);
}
/**
* Do the injection
*/
protected abstract void inject(Target target, MethodInsnNode node);
/**
* @param args
* @param insns
* @param argMap
* @param startArg
* @param endArg
*/
protected void invokeHandlerWithArgs(Type[] args, InsnList insns, int[] argMap, int startArg, int endArg) {
if (!this.isStatic) {
insns.add(new VarInsnNode(Opcodes.ALOAD, 0));
}
this.pushArgs(insns, args, argMap, startArg, endArg);
insns.add(new MethodInsnNode(this.isStatic ? Opcodes.INVOKESTATIC : Opcodes.INVOKESPECIAL,
this.classNode.name, this.methodNode.name, this.methodNode.desc, false));
}
/**
* Generate an array containing local indexes for the specified args, returns an array of identical size to the supplied array with an
* allocated local index in each corresponding position
*/
protected int[] generateArgMap(Type[] args, int start, int local) {
int[] argMap = new int[args.length];
for (int arg = start; arg < args.length; arg++) {
argMap[arg] = local;
local += args[arg].getSize();
}
return argMap;
}
/**
* Store args on the stack starting at the end and working back to position specified by start, return the generated argMap
*/
protected int[] storeArgs(Target target, Type[] args, InsnList insns, int start) {
int[] argMap = this.generateArgMap(args, start, target.method.maxLocals);
this.storeArgs(args, insns, argMap, start, args.length);
return argMap;
}
/**
* Store args on the stack to their positions allocated based on argMap
*/
protected void storeArgs(Type[] args, InsnList insns, int[] argMap, int start, int end) {
for (int arg = end - 1; arg >= start; arg--) {
insns.add(new VarInsnNode(args[arg].getOpcode(Opcodes.ISTORE), argMap[arg]));
}
}
/**
* Load args onto the stack from their positions allocated in argMap
*/
protected void pushArgs(InsnList insns, Type[] args, int[] argMap, int start, int end) {
for (int arg = start; arg < end; arg++) {
insns.add(new VarInsnNode(args[arg].getOpcode(Opcodes.ILOAD), argMap[arg]));
}
}
}
@@ -0,0 +1,161 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke;
import java.util.Arrays;
import java.util.List;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
/**
* A bytecode injector which allows a single argument of a chosen method call to be altered
*/
public class ModifyArgInjector extends InvokeInjector {
/**
* Index of the target arg or -1 to find the arg automatically (only works where there is only one arg of specified type on the element)
*/
private final int index;
/**
* True if processing in single arg mode, the callback only accepts a single arg of the same type as the return. Otherwise the handler method is
* expected to have matching args to the target invocation
*/
private final boolean singleArgMode;
/**
* @param info Injection info
* @param index target arg index
*/
public ModifyArgInjector(InjectionInfo info, int index) {
super(info, "@ModifyArg");
this.index = index;
this.singleArgMode = this.methodArgs.length == 1;
}
/* (non-Javadoc)
* @see org.spongepowered.asm.mixin.injection.callback.BytecodeInjector#sanityCheck(org.spongepowered.asm.mixin.injection.callback.Target,
* java.util.List)
*/
@Override
protected void sanityCheck(Target target, List<InjectionPoint> injectionPoints) {
super.sanityCheck(target, injectionPoints);
if (this.singleArgMode) {
if (!this.methodArgs[0].equals(this.returnType)) {
throw new InvalidInjectionException("@ModifyArg return type must match the parameter type."
+ " ARG=" + this.methodArgs[0] + " RETURN=" + this.returnType);
}
}
}
/**
* Do the injection
*/
@Override
protected void inject(Target target, MethodInsnNode node) {
Type[] args = Type.getArgumentTypes(node.desc);
int argIndex = this.findArgIndex(target, args);
InsnList insns = new InsnList();
int extraLocals = 0;
if (this.singleArgMode) {
extraLocals = this.injectSingleArgHandler(target, args, argIndex, insns);
} else {
extraLocals = this.injectMultiArgHandler(target, args, argIndex, insns);
}
target.method.instructions.insertBefore(node, insns);
target.method.maxLocals = Math.max(target.method.maxLocals, target.maxLocals + extraLocals);
target.method.maxStack = Math.max(target.method.maxStack, target.maxStack + 2 - extraLocals);
}
/**
* Inject handler opcodes for a single arg handler
*/
private int injectSingleArgHandler(Target target, Type[] args, int argIndex, InsnList insns) {
int[] argMap = this.storeArgs(target, args, insns, argIndex);
this.invokeHandlerWithArgs(args, insns, argMap, argIndex, argIndex + 1);
this.pushArgs(insns, args, argMap, argIndex + 1, args.length);
return target.method.maxLocals - argMap[argMap.length - 1] - 1 + args[args.length - 1].getSize();
}
/**
* Inject handler opcodes for a multi arg handler
*/
private int injectMultiArgHandler(Target target, Type[] args, int argIndex, InsnList insns) {
if (!Arrays.equals(args, this.methodArgs)) {
throw new InvalidInjectionException("@ModifyArg method targets a method with an invalid signature "
+ Injector.printArgs(args) + ", expected " + Injector.printArgs(this.methodArgs));
}
int[] argMap = this.storeArgs(target, args, insns, 0);
this.pushArgs(insns, args, argMap, 0, argIndex);
this.invokeHandlerWithArgs(args, insns, argMap, 0, args.length);
this.pushArgs(insns, args, argMap, argIndex + 1, args.length);
return target.method.maxLocals - argMap[argMap.length - 1] - 1 + args[args.length - 1].getSize();
}
protected int findArgIndex(Target target, Type[] args) {
if (this.index > -1) {
if (this.index >= args.length || !args[this.index].equals(this.returnType)) {
throw new InvalidInjectionException("Specified index " + this.index + " for @ModifyArg is invalid for args "
+ Injector.printArgs(args) + ", expected " + this.returnType);
}
return this.index;
}
int argIndex = -1;
for (int arg = 0; arg < args.length; arg++) {
if (!args[arg].equals(this.returnType)) {
continue;
}
if (argIndex != -1) {
throw new InvalidInjectionException("Found duplicate args with index [" + argIndex + ", " + arg + "] matching type "
+ this.returnType + " for @ModifyArg target " + target + " in " + this.classNode.name
+ ". Please specify index of desired arg.");
}
argIndex = arg;
}
if (argIndex == -1) {
throw new InvalidInjectionException("Could not find arg matching type " + this.returnType + " for @ModifyArg target "
+ target + " in " + this.classNode.name);
}
return argIndex;
}
}
@@ -0,0 +1,96 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.invoke;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.util.ASMHelper;
import com.google.common.collect.ObjectArrays;
/**
* <p>A bytecode injector which allows a method call to be redirected to the annotated handler method. The handler method signature must match the
* hooked method precisely <b>but</b> prepended with an arg of the owning object's type to accept the object instance the method was going to be
* invoked on. For example when hooking the following call:</p>
*
* <blockquote><pre>
* int abc = 0;
* int def = 1;
* Foo someObject = new Foo();
*
* // Hooking this method
* boolean xyz = someObject.bar(abc, def);</pre>
* </blockquote>
*
* <p>The signature of the redirected method should be:</p>
*
* <blockquote><pre>public boolean barProxy(Foo someObject, int abc, int def)</pre></blockquote>
*
* <p>For obvious reasons this does not apply for static methods, for static methods it is sufficient that the signature simply match the hooked
* method.</p>
*/
public class RedirectInjector extends InvokeInjector {
/**
* @param info Injection info
*/
public RedirectInjector(InjectionInfo info) {
super(info, "@Redirect");
}
/**
* Do the injection
*/
@Override
protected void inject(Target target, MethodInsnNode node) {
boolean targetIsStatic = node.getOpcode() == Opcodes.INVOKESTATIC;
Type ownerType = Type.getType("L" + node.owner + ";");
Type returnType = Type.getReturnType(node.desc);
Type[] args = Type.getArgumentTypes(node.desc);
Type[] stackVars = targetIsStatic ? args : ObjectArrays.concat(ownerType, args);
String desc = Injector.printArgs(stackVars) + returnType;
if (!desc.equals(this.methodNode.desc)) {
throw new InvalidInjectionException("@Redirect handler method has an invalid signature "
+ ", expected " + desc + " found " + this.methodNode.desc);
}
InsnList insns = new InsnList();
int extraLocals = ASMHelper.getArgsSize(stackVars) + 1;
int[] argMap = this.storeArgs(target, stackVars, insns, 0);
this.invokeHandlerWithArgs(stackVars, insns, argMap, 0, stackVars.length);
target.method.instructions.insertBefore(node, insns);
target.method.instructions.remove(node);
target.method.maxLocals = Math.max(target.method.maxLocals, target.maxLocals + extraLocals);
target.method.maxStack = Math.max(target.method.maxStack, target.maxStack + 1);
}
}
@@ -0,0 +1,47 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.struct;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.callback.CallbackInjector;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.transformer.MixinData;
import org.spongepowered.asm.util.ASMHelper;
public class CallbackInjectionInfo extends InjectionInfo {
protected CallbackInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
super(mixin, method, annotation);
}
@Override
protected Injector initInjector(AnnotationNode injectAnnotation) {
boolean cancellable = ASMHelper.<Boolean>getAnnotationValue(injectAnnotation, "cancellable", false);
boolean captureLocals = ASMHelper.<Boolean>getAnnotationValue(injectAnnotation, "captureLocals", false);
return new CallbackInjector(this, cancellable, captureLocals);
}
}
@@ -33,11 +33,13 @@ import java.util.List;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.InjectionPoint;
import org.spongepowered.asm.mixin.injection.InvalidInjectionException;
import org.spongepowered.asm.mixin.injection.callback.CallbackInjector;
import org.spongepowered.asm.mixin.injection.ModifyArg;
import org.spongepowered.asm.mixin.injection.Redirect;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.transformer.MixinData;
import org.spongepowered.asm.util.ASMHelper;
@@ -45,103 +47,113 @@ import org.spongepowered.asm.util.ASMHelper;
/**
* Contructs information about an injection from an {@link Inject} annotation and allows the injection to be processed
*/
public class InjectionInfo {
public abstract class InjectionInfo {
protected final AnnotationNode annotation;
/**
* Class
*/
private final ClassNode classNode;
protected final ClassNode classNode;
/**
* Annotated method
*/
private final MethodNode method;
protected final MethodNode method;
/**
* Mixin data
*/
protected final MixinData mixin;
/**
* Annotated method is static
*/
private final boolean isStatic;
/**
* True if the injection should be cancellable
*/
private boolean cancellable;
/**
* True if the injection should capture local variables
*/
private boolean captureLocals;
protected final boolean isStatic;
/**
* Target method(s)
*/
private final Deque<MethodNode> targets = new ArrayDeque<MethodNode>();
protected final Deque<MethodNode> targets = new ArrayDeque<MethodNode>();
/**
* Injection points parsed from {@link At} annotations
* Injection points parsed from {@link org.spongepowered.asm.mixin.injection.At} annotations
*/
private final List<InjectionPoint> injectionPoints = new ArrayList<InjectionPoint>();
protected final List<InjectionPoint> injectionPoints = new ArrayList<InjectionPoint>();
/**
* Bytecode injector
*/
private CallbackInjector injector;
protected Injector injector;
/**
* ctor
*
* @param classNode Class
* @param mixin
* @param method Method
* @param injectAnnotation Annotation to parse
* @param annotation Annotation to parse
*/
public InjectionInfo(ClassNode classNode, MethodNode method, MixinData mixin, AnnotationNode injectAnnotation) {
this.classNode = classNode;
protected InjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
this.annotation = annotation;
this.method = method;
this.mixin = mixin;
this.classNode = mixin.getTargetClass();
this.isStatic = ASMHelper.methodIsStatic(method);
this.parse(mixin, injectAnnotation);
this.readAnnotation();
}
/**
* Parse the info from the supplied annotation
*/
private void parse(MixinData mixin, AnnotationNode injectAnnotation) {
if (injectAnnotation == null) {
@SuppressWarnings("unchecked")
protected void readAnnotation() {
if (this.annotation == null) {
return;
}
String method = ASMHelper.<String>getAnnotationValue(injectAnnotation, "method");
String type = "@" + this.annotation.desc.substring(this.annotation.desc.lastIndexOf('/') + 1, this.annotation.desc.length() - 1);
String method = ASMHelper.<String>getAnnotationValue(this.annotation, "method");
if (method == null) {
throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " is missing method name");
throw new InvalidInjectionException(type + " annotation on " + this.method.name + " is missing method name");
}
List<AnnotationNode> ats = ASMHelper.<List<AnnotationNode>>getAnnotationValue(injectAnnotation, "at");
if (ats == null) {
throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " is missing 'at' value(s)");
List<AnnotationNode> ats = null;
Object atValue = ASMHelper.getAnnotationValue(this.annotation, "at");
if (atValue instanceof List) {
ats = (List<AnnotationNode>)atValue;
} else if (atValue instanceof AnnotationNode) {
ats = new ArrayList<AnnotationNode>();
ats.add((AnnotationNode)atValue);
} else {
throw new InvalidInjectionException(type + " annotation on " + this.method.name + " is missing 'at' value(s)");
}
MemberInfo targetMember = MemberInfo.parse(method, mixin);
MemberInfo targetMember = MemberInfo.parse(method, this.mixin);
if (targetMember.owner != null && targetMember.owner.equals(mixin.getTargetClassRef())) {
throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " specifies a target class '" + targetMember.owner
+ "', which is not supported");
if (targetMember.owner != null && targetMember.owner.equals(this.mixin.getTargetClassRef())) {
throw new InvalidInjectionException(type + " annotation on " + this.method.name + " specifies a target class '"
+ targetMember.owner + "', which is not supported");
}
this.findMethods(targetMember);
if (this.targets.size() == 0) {
throw new InvalidInjectionException("@Inject annotation on " + this.method.name + " could not find '" + targetMember.name + "'");
throw new InvalidInjectionException(type + " annotation on " + this.method.name + " could not find '" + targetMember.name + "'");
}
this.cancellable = ASMHelper.<Boolean>getAnnotationValue(injectAnnotation, "cancellable", false);
this.captureLocals = ASMHelper.<Boolean>getAnnotationValue(injectAnnotation, "captureLocals", false);
for (AnnotationNode at : ats) {
InjectionPoint injectionPoint = InjectionPoint.parse(mixin, at);
InjectionPoint injectionPoint = InjectionPoint.parse(this.mixin, at);
if (injectionPoint != null) {
this.injectionPoints.add(injectionPoint);
}
}
this.injector = this.initInjector(this.annotation);
}
protected abstract Injector initInjector(AnnotationNode injectAnnotation);
/**
* Get whether there is enough valid information in this info to actually perform an injection
@@ -154,21 +166,14 @@ public class InjectionInfo {
* Perform the injection
*/
public void inject() {
CallbackInjector injector = this.getInjector();
while (this.targets.size() > 0) {
injector.injectInto(this.targets.removeFirst(), this.injectionPoints);
Target target = this.mixin.getTargetMethod(this.targets.removeFirst());
this.injector.injectInto(target, this.injectionPoints);
}
}
/**
* Performs a full-body massage with scented oils
*/
private CallbackInjector getInjector() {
if (this.injector == null) {
this.injector = new CallbackInjector(this);
}
return this.injector;
public AnnotationNode getAnnotation() {
return this.annotation;
}
/**
@@ -192,20 +197,6 @@ public class InjectionInfo {
return this.targets;
}
/**
* Get whether cancellable or not
*/
public boolean getCancellable() {
return this.cancellable;
}
/**
* Get whether injection should capture locals
*/
public boolean getCaptureLocals() {
return this.captureLocals;
}
/**
* Finds methods in the target class which match searchFor
*
@@ -226,4 +217,28 @@ public class InjectionInfo {
}
}
}
@SuppressWarnings("unchecked")
public static InjectionInfo parse(MixinData mixin, MethodNode method) {
AnnotationNode annotation = null;
try {
annotation = ASMHelper.getSingleVisibleAnnotation(method, Inject.class, ModifyArg.class, Redirect.class);
} catch (IllegalArgumentException ex) {
throw new InvalidMixinException("Error parsing annotations on " + method.name + " in " + mixin.getClassName() + ": " + ex.getMessage());
}
if (annotation == null) {
return null;
}
if (annotation.desc.endsWith(Inject.class.getSimpleName() + ";")) {
return new CallbackInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(ModifyArg.class.getSimpleName() + ";")) {
return new ModifyArgInjectionInfo(mixin, method, annotation);
} else if (annotation.desc.endsWith(Redirect.class.getSimpleName() + ";")) {
return new RedirectInjectionInfo(mixin, method, annotation);
}
return null;
}
}
@@ -28,12 +28,11 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.transformer.MixinData;
/**
* Data read from an {@link At} annotation and passed into an InjectionPoint ctor
* Data read from an {@link org.spongepowered.asm.mixin.injection.At} annotation and passed into an InjectionPoint ctor
*/
public class InjectionPointData {
@@ -0,0 +1,46 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.struct;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.invoke.ModifyArgInjector;
import org.spongepowered.asm.mixin.transformer.MixinData;
import org.spongepowered.asm.util.ASMHelper;
public class ModifyArgInjectionInfo extends InjectionInfo {
public ModifyArgInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
super(mixin, method, annotation);
}
@Override
protected Injector initInjector(AnnotationNode injectAnnotation) {
int index = ASMHelper.<Integer>getAnnotationValue(injectAnnotation, "index", -1);
return new ModifyArgInjector(this, index);
}
}
@@ -0,0 +1,43 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.struct;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.code.Injector;
import org.spongepowered.asm.mixin.injection.invoke.RedirectInjector;
import org.spongepowered.asm.mixin.transformer.MixinData;
public class RedirectInjectionInfo extends InjectionInfo {
public RedirectInjectionInfo(MixinData mixin, MethodNode method, AnnotationNode annotation) {
super(mixin, method, annotation);
}
@Override
protected Injector initInjector(AnnotationNode injectAnnotation) {
return new RedirectInjector(this);
}
}
@@ -0,0 +1,108 @@
/*
* This file is part of Sponge, licensed under the MIT License (MIT).
*
* Copyright (c) SpongePowered.org <http://www.spongepowered.org>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.spongepowered.asm.mixin.injection.struct;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.MethodNode;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
/**
* Information about the current injection target, mainly just convenience rather than passing a bunch of values around
*/
public class Target {
/**
* Target method
*/
public final MethodNode method;
/**
* Method arguments
*/
public final Type[] arguments;
/**
* Return type computed from the method descriptor
*/
public final Type returnType;
/**
* Method's (original) MAXS
*/
public final int maxStack;
/**
* Method's original max locals
*/
public final int maxLocals;
/**
* Callback method descriptor based on this target
*/
public final String callbackDescriptor;
/**
* Callback info class
*/
public final String callbackInfoClass;
/**
* Make a new Target for the supplied method
*/
public Target(MethodNode method) {
this.method = method;
this.arguments = Type.getArgumentTypes(method.desc);
this.returnType = Type.getReturnType(method.desc);
this.maxStack = method.maxStack;
this.maxLocals = method.maxLocals;
this.callbackInfoClass = CallbackInfo.getCallInfoClassName(this.returnType);
this.callbackDescriptor = String.format("(%sL%s;)V", method.desc.substring(1, method.desc.indexOf(')')), this.callbackInfoClass);
}
/**
* Get the callback descriptor
*/
public String getCallbackDescriptor(final boolean captureLocals, final Type[] locals, Type[] argumentTypes, int startIndex) {
if (!captureLocals) {
return this.callbackDescriptor;
}
String descriptor = this.callbackDescriptor.substring(0, this.callbackDescriptor.indexOf(')'));
for (int l = startIndex; l < locals.length; l++) {
if (locals[l] != null) {
descriptor += locals[l].getDescriptor();
}
}
return descriptor + ")V";
}
@Override
public String toString() {
return this.method.name + this.method.desc;
}
}
@@ -42,6 +42,7 @@ import org.spongepowered.asm.mixin.Implements;
import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.struct.ReferenceMapper;
import org.spongepowered.asm.mixin.injection.struct.Target;
import org.spongepowered.asm.util.ASMHelper;
@@ -61,6 +62,11 @@ public class MixinData {
*/
private final ClassNode classNode;
/**
*
*/
private final ClassNode targetClass;
/**
* Methods we need to rename
*/
@@ -75,15 +81,21 @@ public class MixinData {
* All interfaces implemented by this mixin, including soft implementations
*/
private final Set<String> interfaces = new HashSet<String>();
/**
* Information about methods in the target class, used to keep track of transformations we apply
*/
private final Map<String, Target> targetMethods = new HashMap<String, Target>();
/**
* ctor
*
* @param info
*/
MixinData(MixinInfo info) {
MixinData(MixinInfo info, ClassNode target) {
this.info = info;
this.classNode = info.getClassNode(ClassReader.EXPAND_FRAMES);
this.targetClass = target;
this.prepare();
}
@@ -118,6 +130,30 @@ public class MixinData {
}
return targetClasses.get(0);
}
/**
* Get the target class
*/
public ClassNode getTargetClass() {
return this.targetClass;
}
/**
* Get a method from the target class
*/
public Target getTargetMethod(MethodNode method) {
if (!this.targetClass.methods.contains(method)) {
throw new IllegalArgumentException("Invalid target method supplied to getTargetMethod()");
}
String targetName = method.name + method.desc;
Target target = this.targetMethods.get(targetName);
if (target == null) {
target = new Target(method);
this.targetMethods.put(targetName, target);
}
return target;
}
/**
* Get all interfaces for this mixin
@@ -139,7 +175,7 @@ public class MixinData {
public ReferenceMapper getReferenceMapper() {
return this.info.getParent().getReferenceMapper();
}
/**
* Prepare the mixin, applies any pre-processing transformations
*/
@@ -230,10 +230,11 @@ class MixinInfo extends TreeInfo implements Comparable<MixinInfo> {
/**
* Get a new mixin data container for this info
*
* @param target
* @return
*/
public MixinData getData() {
return new MixinData(this);
public MixinData createData(ClassNode target) {
return new MixinData(this, target);
}
/**
@@ -40,7 +40,6 @@ import org.apache.logging.log4j.core.helpers.Booleans;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.AnnotationNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.FieldNode;
@@ -51,7 +50,6 @@ import org.spongepowered.asm.mixin.InvalidMixinException;
import org.spongepowered.asm.mixin.MixinEnvironment;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
import org.spongepowered.asm.transformers.TreeTransformer;
import org.spongepowered.asm.util.ASMHelper;
@@ -143,7 +141,7 @@ public class MixinTransformer extends TreeTransformer {
for (MixinInfo mixin : mixins) {
this.logger.info("Mixing {} into {}", mixin.getName(), transformedName);
this.applyMixin(targetClass, mixin.getData());
this.applyMixin(targetClass, mixin.createData(targetClass));
}
// Extension point
@@ -394,17 +392,16 @@ public class MixinTransformer extends TreeTransformer {
*/
private void applyInjections(ClassNode targetClass, MixinData mixin) {
for (MethodNode method : targetClass.methods) {
AnnotationNode injectAnnotation = ASMHelper.getVisibleAnnotation(method, Inject.class);
if (injectAnnotation == null) {
InjectionInfo injectInfo = InjectionInfo.parse(mixin, method);
if (injectInfo == null) {
continue;
}
InjectionInfo injectInfo = new InjectionInfo(targetClass, method, mixin, injectAnnotation);
if (injectInfo.isValid()) {
injectInfo.inject();
}
method.visibleAnnotations.remove(injectAnnotation);
method.visibleAnnotations.remove(injectInfo.getAnnotation());
}
}
@@ -46,6 +46,7 @@ import org.objectweb.asm.util.CheckClassAdapter;
import java.io.PrintWriter;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@@ -388,6 +389,28 @@ public class ASMHelper {
return ASMHelper.getAnnotation(method.invisibleAnnotations, Type.getDescriptor(annotationClass));
}
/**
* Get a runtime-visible annotation of the specified class from the supplied method node
*
* @param method Source method
* @param annotationClasses Types of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getSingleVisibleAnnotation(MethodNode method, Class<? extends Annotation>... annotationClasses) {
return ASMHelper.getSingleAnnotation(method.visibleAnnotations, annotationClasses);
}
/**
* Get an invisible annotation of the specified class from the supplied method node
*
* @param method Source method
* @param annotationClasses Types of annotation to search for
* @return the annotation, or null if not present
*/
public static AnnotationNode getSingleInvisibleAnnotation(MethodNode method, Class<? extends Annotation>... annotationClasses) {
return ASMHelper.getSingleAnnotation(method.invisibleAnnotations, annotationClasses);
}
/**
* Get a runtime-visible annotation of the specified class from the supplied class node
*
@@ -432,6 +455,23 @@ public class ASMHelper {
return null;
}
private static AnnotationNode getSingleAnnotation(List<AnnotationNode> annotations, Class<? extends Annotation>... annotationClasses) {
List<AnnotationNode> nodes = new ArrayList<AnnotationNode>();
for (Class<? extends Annotation> annotationClass : annotationClasses) {
AnnotationNode annotation = ASMHelper.getAnnotation(annotations, Type.getDescriptor(annotationClass));
if (annotation != null) {
nodes.add(annotation);
}
}
int foundNodes = nodes.size();
if (foundNodes > 1) {
throw new IllegalArgumentException("Conflicting annotations found: " + annotationClasses);
}
return foundNodes == 0 ? null : nodes.get(0);
}
/**
* Duck type the "value" entry (if any) of the specified annotation node
*