From cd215795d2ca0b16f6fb22bb6d78bee378e7e59d Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Mon, 1 Feb 2016 15:46:05 +0000 Subject: [PATCH] Support for modifying local variables in methods --- gradle.properties | 2 +- .../InjectionObfuscationProcessor.java | 2 + .../asm/launch/MixinBootstrap.java | 2 +- .../asm/mixin/injection/Inject.java | 5 +- .../asm/mixin/injection/ModifyArg.java | 5 +- .../asm/mixin/injection/ModifyVariable.java | 187 ++++++++++ .../asm/mixin/injection/Redirect.java | 5 +- .../injection/callback/CallbackInjector.java | 2 + .../asm/mixin/injection/code/Injector.java | 18 +- .../injection/invoke/InvokeInjector.java | 14 +- .../modify/ModifyVariableInjector.java | 331 ++++++++++++++++++ .../struct/CallbackInjectionInfo.java | 1 + .../mixin/injection/struct/InjectionInfo.java | 19 +- .../struct/ModifyArgInjectionInfo.java | 6 + .../struct/ModifyVariableInjectionInfo.java | 65 ++++ .../struct/RedirectInjectionInfo.java | 6 + 16 files changed, 643 insertions(+), 27 deletions(-) create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/ModifyVariable.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/modify/ModifyVariableInjector.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyVariableInjectionInfo.java diff --git a/gradle.properties b/gradle.properties index d26d42e9..08b5a94a 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,5 +4,5 @@ packaging=jar description=Mixin url=https://www.spongepowered.org organization=SpongePowered -buildVersion=0.4.17 +buildVersion=0.4.18 buildType=SNAPSHOT diff --git a/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java b/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java index 2dbd81ac..99861657 100644 --- a/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java +++ b/src/ap/java/org/spongepowered/tools/obfuscation/InjectionObfuscationProcessor.java @@ -39,6 +39,7 @@ 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.ModifyVariable; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.tools.MirrorUtils; @@ -69,6 +70,7 @@ public class InjectionObfuscationProcessor extends MixinProcessor { this.processInjectors(roundEnv, Inject.class); this.processInjectors(roundEnv, ModifyArg.class); this.processInjectors(roundEnv, Redirect.class); + this.processInjectors(roundEnv, ModifyVariable.class); this.postProcess(roundEnv); return true; diff --git a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java index acad8e63..4938f14a 100644 --- a/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java +++ b/src/main/java/org/spongepowered/asm/launch/MixinBootstrap.java @@ -60,7 +60,7 @@ public abstract class MixinBootstrap { /** * Subsystem version */ - public static final String VERSION = "0.4.17"; + public static final String VERSION = "0.4.18"; /** * Blackboard key where the subsystem version will be stored to indicate diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java b/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java index f9096e7e..5f065f74 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java @@ -147,9 +147,10 @@ public @interface Inject { * specified is not achieved then an {@link InjectionError} is thrown at * application time. Use this option with care.

* - * @return Minimum required number of injected callbacks, default 0 + * @return Minimum required number of injected callbacks, default specified + * by the containing config */ - public int require() default 0; + public int require() default -1; /** * Like {@link #require()} but only enabled if the diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/ModifyArg.java b/src/main/java/org/spongepowered/asm/mixin/injection/ModifyArg.java index a18e8e3f..d034db09 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/ModifyArg.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/ModifyArg.java @@ -106,9 +106,10 @@ public @interface ModifyArg { * specified is not achieved then an {@link InjectionError} is thrown at * application time. Use this option with care.

* - * @return Minimum required number of injected callbacks, default 0 + * @return Minimum required number of injected callbacks, default specified + * by the containing config */ - public int require() default 0; + public int require() default -1; /** * Like {@link #require()} but only enabled if the diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/ModifyVariable.java b/src/main/java/org/spongepowered/asm/mixin/injection/ModifyVariable.java new file mode 100644 index 00000000..ce4e2290 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/ModifyVariable.java @@ -0,0 +1,187 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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; + +import org.spongepowered.asm.mixin.MixinEnvironment.Option; + +/** + * Specifies that this mixin method should inject a variable modifier callback + * to itself in the target method(s) identified by {@link #method}. + * + *

ModifyVariable callbacks should always take one argument of the + * type to capture and return the same type. For example a ModifyVariable + * for a local of type {@link String} should have the signature:

+ * + * private String methodName(String variable) { ... + * + *

The callback receives the current value of the local variable, and should + * return the new value.

+ * + *

The injector has two operating modes, explicit and implicit + * , and can operate either on the entire LVT or on the method arguments + * only

. + * + *

In explicit mode, the variable to capture can be specified by + * specifying values for the discriminator arguments {@link ordinal}, + * {@link index} and {@link name}. The injector uses the discriminators in order + * to attempt to locate the variable to capture. If no local variable matches + * any discriminators, the capture fails.

+ * + *

If no values for the capture discrimiators are specified, the injector + * operates in implicit mode. If exactly one variable of the capture + * type exists in the target LVT, then capture will succeed. However, if more + * than one variable of the required type is encountered in the LVT then an + * {@link InvalidInjectionException} is thrown.

+ */ +@Target({ ElementType.METHOD }) +@Retention(RetentionPolicy.RUNTIME) +public @interface ModifyVariable { + + /** + * String representation of a + * {@link org.spongepowered.asm.mixin.injection.struct.MemberInfo + * MemberInfo} which identifies the target method. + * + * @return target method + */ + public String method(); + + /** + * An {@link At} annotation which describes the {@link InjectionPoint} in + * the target method. The specified {@link InjectionPoint} must only + * return {@link org.spongepowered.asm.lib.tree.MethodInsnNode} instances + * and an exception will be thrown if this is not the case. + * + * @return {@link At} which identifies the target method invocation + */ + public At at(); + + /** + * When creating a {@link ModifyVariable} callback, you may wish to first + * inspect the local variable table in the target method at the injection + * point. Set this value to true to print the local variable table + * and perform no injection. + * + * @return true to print the LVT to the console + */ + public boolean print() default false; + + /** + * Gets the local variable ordinal by type. For example, if there are 3 + * {@link String} arguments in the local variable table, ordinal 0 specifies + * the first, 1 specifies the second, etc. Use ordinal when the + * index within the LVT is known. Takes precedence over {@link index}. + * + * @return variable ordinal + */ + public int ordinal() default -1; + + /** + * Gets the absolute index of the local variable within the local variable + * table to capture. The local variable at the specified index must be of + * the same type as the capture. Takes precedence over {@link name}. + * + * @return argument index to modify or -1 for automatic + */ + public int index() default -1; + + /** + * Gets the name of the variable to capture. Only used if the variable + * cannot be located via {@link ordinal} or {@link index}. + * + * @return possible names to capture, only useful when the LVT in the target + * method is known to be complete. + */ + public String[] name() default {}; + + /** + * Under normal circumstances the injector will consider all local variables + * including method arguments and all other local variables. This involves + * reading (and possibly generating) the local variable table for the method + * which can have mixed results. Set this value to true to only + * consider method arguments. + * + * @return true if this injector should only consider method arguments and + * not all locals. + */ + public boolean argsOnly() default false; + + /** + * By default, the annotation processor will attempt to locate an + * obfuscation mapping for all {@link ModifyVariable} methods since it is + * anticipated that in general the target of a {@link ModifyVariable} + * 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 false will cause + * the annotation processor to skip this annotation when attempting to build + * the obfuscation table for the mixin. + * + * @return True to instruct the annotation processor to search for + * obfuscation mappings for this annotation + */ + public boolean remap() default true; + + /** + * In general, injectors are intended to "fail soft" in that a failure to + * locate the injection point in the target method is not considered an + * error condition. Another transformer may have changed the method + * structure or any number of reasons may cause an injection to fail. This + * also makes it possible to define several injections to achieve the same + * task given expected mutation of the target class and the + * injectors which fail are simply ignored. + * + *

However, this behaviour is not always desirable. For example, if your + * application depends on a particular injection succeeding you may wish to + * detect the injection failure as an error condition. This argument is thus + * provided to allow you to stipulate a minimum number of successful + * injections for this callback handler. If the number of injections + * specified is not achieved then an {@link InjectionError} is thrown at + * application time. Use this option with care.

+ * + * @return Minimum required number of injected callbacks, default specified + * by the containing config + */ + public int require() default -1; + + /** + * Like {@link #require()} but only enabled if the + * {@link Option#DEBUG_INJECTORS mixin.debug.countInjections} option is set + * to true and defaults to 1. Use this option during debugging to + * perform simple checking of your injectors. Causes the injector to throw + * a {@link InvalidInjectionException} if the expected number of injections + * is not realised. + * + * @return Minimum number of expected callbacks, default 1 + */ + public int expect() default 1; + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/Redirect.java b/src/main/java/org/spongepowered/asm/mixin/injection/Redirect.java index 1fc1ac95..4e62a3ff 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/Redirect.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/Redirect.java @@ -128,9 +128,10 @@ public @interface Redirect { * specified is not achieved then an {@link InjectionError} is thrown at * application time. Use this option with care.

* - * @return Minimum required number of injected callbacks, default 0 + * @return Minimum required number of injected callbacks, default specified + * by the containing config */ - public int require() default 0; + public int require() default -1; /** * Like {@link #require()} but only enabled if the diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java index 75b927b8..874a60de 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/CallbackInjector.java @@ -310,6 +310,8 @@ public class CallbackInjector extends Injector { */ @Override protected void sanityCheck(Target target, List injectionPoints) { + super.sanityCheck(target, injectionPoints); + if (ASMHelper.methodIsStatic(target.method) != this.isStatic) { throw new InvalidInjectionException(this.info, "'static' modifier of callback method does not match target in " + this.methodNode.name); } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/code/Injector.java b/src/main/java/org/spongepowered/asm/mixin/injection/code/Injector.java index 9ddfd250..fafe0188 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/code/Injector.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/code/Injector.java @@ -65,6 +65,16 @@ public abstract class Injector { * Callback method */ protected final MethodNode methodNode; + + /** + * Arguments of the handler method + */ + protected final Type[] methodArgs; + + /** + * Return type of the handler method + */ + protected final Type returnType; /** * True if the callback method is static @@ -90,6 +100,8 @@ public abstract class Injector { private Injector(ClassNode classNode, MethodNode methodNode) { this.classNode = classNode; this.methodNode = methodNode; + this.methodArgs = Type.getArgumentTypes(this.methodNode.desc); + this.returnType = Type.getReturnType(this.methodNode.desc); this.isStatic = ASMHelper.methodIsStatic(this.methodNode); } @@ -126,7 +138,7 @@ public abstract class Injector { for (InjectionPoint injectionPoint : injectionPoints) { nodes.clear(); - if (injectionPoint.find(into.desc, insns, nodes)) { + if (this.findTargetNodes(into, injectionPoint, insns, nodes)) { targetNodes.addAll(nodes); } } @@ -135,6 +147,10 @@ public abstract class Injector { return targetNodes; } + protected boolean findTargetNodes(MethodNode into, InjectionPoint injectionPoint, ReadOnlyInsnList insns, Collection nodes) { + return injectionPoint.find(into.desc, insns, nodes); + } + protected void sanityCheck(Target target, List injectionPoints) { // stub for subclasses } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/InvokeInjector.java b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/InvokeInjector.java index 7dc20ba6..967bd2d6 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/invoke/InvokeInjector.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/invoke/InvokeInjector.java @@ -43,16 +43,6 @@ import org.spongepowered.asm.mixin.injection.struct.Target; */ 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; /** @@ -61,8 +51,6 @@ public abstract class InvokeInjector extends Injector { */ 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; } @@ -73,6 +61,8 @@ public abstract class InvokeInjector extends Injector { */ @Override protected void sanityCheck(Target target, List injectionPoints) { + super.sanityCheck(target, injectionPoints); + if (target.isStatic != this.isStatic) { throw new InvalidInjectionException(this.info, "'static' modifier of callback method does not match target in " + this.methodNode.name); } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/modify/ModifyVariableInjector.java b/src/main/java/org/spongepowered/asm/mixin/injection/modify/ModifyVariableInjector.java new file mode 100644 index 00000000..aef5beb4 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/modify/ModifyVariableInjector.java @@ -0,0 +1,331 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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.modify; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.spongepowered.asm.lib.Opcodes; +import org.spongepowered.asm.lib.Type; +import org.spongepowered.asm.lib.tree.AbstractInsnNode; +import org.spongepowered.asm.lib.tree.ClassNode; +import org.spongepowered.asm.lib.tree.InsnList; +import org.spongepowered.asm.lib.tree.LocalVariableNode; +import org.spongepowered.asm.lib.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.modify.ModifyVariableInjector.Context.Local; +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; +import org.spongepowered.asm.util.PrettyPrinter; +import org.spongepowered.asm.util.SignaturePrinter; + +/** + * A bytecode injector which allows a single argument of a chosen method call to + * be altered. + */ +public class ModifyVariableInjector extends Injector { + + class Context extends InsnList { + + class Local { + + int ord = 0; + String name; + Type type; + + public Local(String name, Type type) { + this.name = name; + this.type = type; + } + + @Override + public String toString() { + return String.format("Local[ordinal=%d, name=%s, type=%s]", this.ord, this.name, this.type); + } + + } + + final Target target; + final AbstractInsnNode node; + final int baseArgIndex; + final Local[] locals; + + private final ClassNode targetClass; + private final boolean isStaticHandler; + + public Context(ClassNode targetClass, boolean isStaticHandler, Target target, AbstractInsnNode node, boolean argsOnly) { + this.targetClass = targetClass; + this.isStaticHandler = isStaticHandler; + this.target = target; + this.node = node; + this.baseArgIndex = this.isStaticHandler ? 0 : 1; + this.locals = this.initLocals(target, node, argsOnly); + this.initOrdinals(); + } + + private Local[] initLocals(Target target, AbstractInsnNode node, boolean argsOnly) { + if (!argsOnly) { + LocalVariableNode[] locals = Locals.getLocalsAt(this.targetClass, target.method, node); + if (locals != null) { + Local[] lvt = new Local[locals.length]; + for (int l = 0; l < locals.length; l++) { + if (locals[l] != null) { + lvt[l] = new Local(locals[l].name, Type.getType(locals[l].desc)); + } + } + return lvt; + } + } + + Local[] lvt = new Local[this.baseArgIndex + target.arguments.length]; + if (!this.isStaticHandler) { + lvt[0] = new Local("this", Type.getType(this.targetClass.name)); + } + for (int local = this.baseArgIndex; local < lvt.length; local++) { + Type arg = target.arguments[local - this.baseArgIndex]; + lvt[local] = new Local("arg" + local, arg); + } + return lvt; + } + + private void initOrdinals() { + Map ordinalMap = new HashMap(); + for (int l = 0; l < this.locals.length; l++) { + Integer ordinal = Integer.valueOf(0); + if (this.locals[l] != null) { + ordinal = ordinalMap.get(this.locals[l].type); + ordinalMap.put(this.locals[l].type, ordinal = Integer.valueOf(ordinal == null ? 0 : ordinal.intValue() + 1)); + this.locals[l].ord = ordinal.intValue(); + } + } + } + + } + + /** + * Print LVT + */ + private final boolean print; + + /** + * True to consider only method args + */ + private final boolean argsOnly; + + /** + * Ordinal of the target variable or -1 to fail over to {@link index} + */ + private final int ordinal; + + /** + * Ordinal of the target variable or -1 to fail over to {@link names} + */ + private final int index; + + /** + * Candidate names for the local variable, if empty fails over to matching + * single local by type + */ + private final Set names; + + /** + * @param info Injection info + * @param print + * @param argsOnly + * @param ordinal target variable ordinal + * @param index target variable index + * @param names target variable names + */ + public ModifyVariableInjector(InjectionInfo info, boolean print, boolean argsOnly, int ordinal, int index, Set names) { + super(info); + + this.print = print; + this.argsOnly = argsOnly; + this.ordinal = ordinal; + this.index = index; + this.names = names; + } + + /* (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 injectionPoints) { + super.sanityCheck(target, injectionPoints); + + if (target.isStatic != this.isStatic) { + throw new InvalidInjectionException(this.info, "'static' of variable modifier method does not match target in " + this.methodNode.name); + } + + if (this.ordinal < -1) { + throw new InvalidInjectionException(this.info, "Invalid ordinal " + this.ordinal + " specified in " + this.methodNode.name); + } + + if (this.index == 0 && !this.isStatic) { + throw new InvalidInjectionException(this.info, "Invalid index 0 specified in non-static variable modifier " + this.methodNode.name); + } + } + + /** + * If the user specifies no values for {@link ordinal}, {@link index} or + * {@link names} then we are considered to be operating in "implicit mode" + * where only a single local variable of the specified type is expected to + * exist. + * + * @param context Target context + * @return true if operating in implicit mode + */ + protected boolean isImplicitMode(final Context context) { + return this.ordinal < 0 && this.index < context.baseArgIndex && this.names.isEmpty(); + } + + /** + * Do the injection + */ + @Override + protected void inject(Target target, AbstractInsnNode node) { + Context context = new Context(this.classNode, this.isStatic, target, node, this.argsOnly); + + if (this.print) { + this.printLocals(context); + } + + int local = this.findLocal(context); + if (local > -1) { + this.inject(context, local); + } + + target.insns.insertBefore(node, context); + target.addToStack(this.isStatic ? 1 : 2); + } + + /** + * Pretty-print local variable information to stderr + */ + private void printLocals(final Context context) { + SignaturePrinter handlerSig = new SignaturePrinter(this.methodNode.name, this.returnType, this.methodArgs, new String[] { "var" }); + handlerSig.setModifiers(this.methodNode); + + PrettyPrinter printer = new PrettyPrinter(); + printer.add("%20s : %s", "Target Class", this.classNode.name.replace('/', '.')); + printer.add("%20s : %s", "Target Method", context.target.method.name); + printer.add("%20s : %s", "Callback Name", this.methodNode.name); + printer.add("%20s : %s", "Capture Type", SignaturePrinter.getTypeName(this.returnType, false)); + printer.add("%20s : %s %s", "Instruction", context.node.getClass().getSimpleName(), ASMHelper.getOpcodeName(context.node.getOpcode())).hr(); + printer.add("%20s : %s", "Match mode", this.isImplicitMode(context) ? "IMPLICIT (match single)" : "EXPLICIT (match by criteria)"); + printer.add("%20s : %s", "Match ordinal", this.ordinal < 0 ? "any" : this.ordinal); + printer.add("%20s : %s", "Match index", this.index < context.baseArgIndex ? "any" : this.index); + printer.add("%20s : %s", "Match name(s)", this.names.isEmpty() ? "any" : this.names); + printer.add("%20s : %s", "Args only", this.argsOnly).hr(); + printer.add("%5s %7s %20s %-50s %s", "INDEX", "ORDINAL", "TYPE", "NAME", "CANDIDATE"); + for (int l = context.baseArgIndex; l < context.locals.length; l++) { + Local local = context.locals[l]; + if (local != null) { + Type localType = local.type; + String localName = local.name; + int ordinal = local.ord; + String candidate = this.returnType.equals(localType) ? "YES" : "-"; + printer.add("[%3d] [%3d] %20s %-50s %s", l, ordinal, SignaturePrinter.getTypeName(localType, false), localName, candidate); + } else if (l > 0) { + Local prevLocal = context.locals[l - 1]; + boolean isTop = prevLocal != null && prevLocal.type != null && prevLocal.type.getSize() > 1; + printer.add("[%3d] %20s", l, isTop ? "" : "-"); + } + } + printer.print(System.err); + } + + private void inject(final Context context, final int local) { + if (!this.isStatic) { + context.add(new VarInsnNode(Opcodes.ALOAD, 0)); + } + + context.add(new VarInsnNode(this.returnType.getOpcode(Opcodes.ILOAD), local)); + this.invokeHandler(context); + context.add(new VarInsnNode(this.returnType.getOpcode(Opcodes.ISTORE), local)); + } + + private int findLocal(Context context) { + if (this.isImplicitMode(context)) { + return this.findImplicitLocal(context); + } + return this.findExplicitLocal(context); + } + + private int findImplicitLocal(final Context context) { + int found = 0; + int count = 0; + for (int index = context.baseArgIndex; index < context.locals.length; index++) { + Local local = context.locals[index]; + if (local == null || !local.type.equals(this.returnType)) { + continue; + } + count++; + found = index; + } + + if (count == 1) { + return found; + } + + throw new InvalidInjectionException(this.info, "Implicit variable modifier injection failed in " + this.methodNode.name + ", found " + + count + " candidate variables but exactly 1 is required."); + } + + private int findExplicitLocal(final Context context) { + for (int index = context.baseArgIndex; index < context.locals.length; index++) { + Local local = context.locals[index]; + if (local == null || !local.type.equals(this.returnType)) { + continue; + } + if (this.ordinal > -1) { + if (this.ordinal == local.ord) { + return index; + } + continue; + } + if (this.index >= context.baseArgIndex) { + if (this.index == index) { + return index; + } + continue; + } + if (this.names.contains(local.name)) { + return index; + } + } + + return -1; + } + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/CallbackInjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/CallbackInjectionInfo.java index 80149326..313a55f7 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/CallbackInjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/CallbackInjectionInfo.java @@ -45,4 +45,5 @@ public class CallbackInjectionInfo extends InjectionInfo { return new CallbackInjector(this, cancellable, locals); } + } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java index 2d65e8dd..0c68ba52 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/InjectionInfo.java @@ -42,6 +42,7 @@ import org.spongepowered.asm.mixin.injection.InjectionPoint; import org.spongepowered.asm.mixin.injection.InjectorGroupInfo; import org.spongepowered.asm.mixin.injection.InvalidInjectionException; import org.spongepowered.asm.mixin.injection.ModifyArg; +import org.spongepowered.asm.mixin.injection.ModifyVariable; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.code.Injector; import org.spongepowered.asm.mixin.transformer.InvalidMixinException; @@ -192,7 +193,7 @@ public abstract class InjectionInfo { } Integer require = ASMHelper.getAnnotationValue(this.annotation, "require"); - if (require != null) { + if (require != null && require.intValue() > -1) { this.requiredCallbackCount = require.intValue(); } else if (this.group.isDefault()) { this.requiredCallbackCount = this.mixin.getDefaultRequiredInjections(); @@ -234,15 +235,19 @@ public abstract class InjectionInfo { if ((MixinEnvironment.getCurrentEnvironment().getOption(Option.DEBUG_INJECTORS) && this.injectedCallbackCount < this.expectedCallbackCount)) { throw new InvalidInjectionException(this, - String.format("Injection validation failed: Callback method %s%s in %s expected %d invocation(s) but %d succeeded", - this.method.name, this.method.desc, this.mixin, this.expectedCallbackCount, this.injectedCallbackCount)); + String.format("Injection validation failed: %s %s%s in %s expected %d invocation(s) but %d succeeded", + this.getDescription(), this.method.name, this.method.desc, this.mixin, this.expectedCallbackCount, this.injectedCallbackCount)); } else if (this.injectedCallbackCount < this.requiredCallbackCount) { throw new InjectionError( - String.format("Critical injection failure: Callback method %s%s in %s failed injection check, (%d/%d) succeeded", - this.method.name, this.method.desc, this.mixin, this.injectedCallbackCount, this.requiredCallbackCount)); + String.format("Critical injection failure: %s %s%s in %s failed injection check, (%d/%d) succeeded", + this.getDescription(), this.method.name, this.method.desc, this.mixin, this.injectedCallbackCount, this.requiredCallbackCount)); } } + protected String getDescription() { + return "Callback method"; + } + @Override public String toString() { return String.format("%s->@%s::%s%s", this.mixin.toString(), this.annotationType, this.method.name, this.method.desc); @@ -356,7 +361,7 @@ public abstract class InjectionInfo { public static InjectionInfo parse(MixinTargetContext mixin, MethodNode method) { AnnotationNode annotation = null; try { - annotation = ASMHelper.getSingleVisibleAnnotation(method, Inject.class, ModifyArg.class, Redirect.class); + annotation = ASMHelper.getSingleVisibleAnnotation(method, Inject.class, ModifyArg.class, Redirect.class, ModifyVariable.class); } catch (IllegalArgumentException ex) { throw new InvalidMixinException(mixin, "Error parsing annotations on " + method.name + " in " + mixin.getClassName() + ": " + ex.getMessage()); @@ -372,6 +377,8 @@ public abstract class InjectionInfo { return new ModifyArgInjectionInfo(mixin, method, annotation); } else if (annotation.desc.endsWith(Redirect.class.getSimpleName() + ";")) { return new RedirectInjectionInfo(mixin, method, annotation); + } else if (annotation.desc.endsWith(ModifyVariable.class.getSimpleName() + ";")) { + return new ModifyVariableInjectionInfo(mixin, method, annotation); } return null; diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyArgInjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyArgInjectionInfo.java index 76031d9d..5b0ab5cd 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyArgInjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyArgInjectionInfo.java @@ -43,4 +43,10 @@ public class ModifyArgInjectionInfo extends InjectionInfo { return new ModifyArgInjector(this, index); } + + @Override + protected String getDescription() { + return "Argument modifier method"; + } + } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyVariableInjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyVariableInjectionInfo.java new file mode 100644 index 00000000..5a0b4d39 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/ModifyVariableInjectionInfo.java @@ -0,0 +1,65 @@ +/* + * This file is part of Mixin, licensed under the MIT License (MIT). + * + * Copyright (c) SpongePowered + * 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 java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.spongepowered.asm.lib.tree.AnnotationNode; +import org.spongepowered.asm.lib.tree.MethodNode; +import org.spongepowered.asm.mixin.injection.code.Injector; +import org.spongepowered.asm.mixin.injection.modify.ModifyVariableInjector; +import org.spongepowered.asm.mixin.transformer.MixinTargetContext; +import org.spongepowered.asm.util.ASMHelper; + +public class ModifyVariableInjectionInfo extends InjectionInfo { + + public ModifyVariableInjectionInfo(MixinTargetContext mixin, MethodNode method, AnnotationNode annotation) { + super(mixin, method, annotation); + } + + @Override + protected Injector initInjector(AnnotationNode injectAnnotation) { + boolean print = ASMHelper.getAnnotationValue(injectAnnotation, "print", Boolean.FALSE).booleanValue(); + boolean argsOnly = ASMHelper.getAnnotationValue(injectAnnotation, "argsOnly", Boolean.FALSE).booleanValue(); + int ordinal = ASMHelper.getAnnotationValue(injectAnnotation, "ordinal", -1); + int index = ASMHelper.getAnnotationValue(injectAnnotation, "index", -1); + + Set names = new HashSet(); + List namesList = ASMHelper.>getAnnotationValue(injectAnnotation, "name", (List)null); + if (namesList != null) { + names.addAll(namesList); + } + + return new ModifyVariableInjector(this, print, argsOnly, ordinal, index, names); + } + + @Override + protected String getDescription() { + return "Variable modifier method"; + } + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/RedirectInjectionInfo.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/RedirectInjectionInfo.java index fba241ff..e3396041 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/RedirectInjectionInfo.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/RedirectInjectionInfo.java @@ -40,4 +40,10 @@ public class RedirectInjectionInfo extends InjectionInfo { protected Injector initInjector(AnnotationNode injectAnnotation) { return new RedirectInjector(this); } + + @Override + protected String getDescription() { + return "Redirector"; + } + }