From 6f09fade5c74855886352bafaeb0a918e3e50219 Mon Sep 17 00:00:00 2001 From: Mumfrey Date: Thu, 5 Mar 2015 19:02:06 +0000 Subject: [PATCH] Add failure handling for local capture, enable local capture in @Inject --- .../asm/mixin/injection/Inject.java | 49 +++- .../asm/mixin/injection/InjectionError.java | 54 ++++ .../asm/mixin/injection/Surrogate.java | 41 +++ .../injection/callback/CallbackInjector.java | 245 +++++++++++++++--- .../injection/callback/LocalCapture.java | 92 +++++++ .../asm/mixin/injection/code/Injector.java | 8 +- .../struct/CallbackInjectionInfo.java | 5 +- .../mixin/injection/struct/InjectionInfo.java | 30 +++ .../asm/mixin/injection/struct/Target.java | 2 +- .../mixin/transformer/MixinTransformer.java | 7 + .../org/spongepowered/asm/util/ASMHelper.java | 2 +- .../org/spongepowered/asm/util/Locals.java | 9 +- .../spongepowered/asm/util/PrettyPrinter.java | 109 ++++++++ .../asm/util/SignaturePrinter.java | 195 ++++++++++++++ 14 files changed, 795 insertions(+), 53 deletions(-) create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/InjectionError.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/Surrogate.java create mode 100644 src/main/java/org/spongepowered/asm/mixin/injection/callback/LocalCapture.java create mode 100644 src/main/java/org/spongepowered/asm/util/PrettyPrinter.java create mode 100644 src/main/java/org/spongepowered/asm/util/SignaturePrinter.java 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 425683da..b14469b2 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/Inject.java @@ -29,6 +29,9 @@ import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.LocalCapture; + /** * Specifies that this mixin method should inject a callback (or * callbacks) to itself in the target method(s) identified by @@ -60,9 +63,7 @@ public @interface Inject { * Setting an injected callback to cancellable allows the injected * callback to inject optional RETURN opcodes into the target method, the * return behaviour can then be controlled from within the callback by - * interacting with the supplied - * {@link org.spongepowered.asm.mixin.injection.callback.CallbackInfo} - * object. + * interacting with the supplied {@link CallbackInfo} object. * * @return true if this injector should inject appropriate RETURN opcodes * which allow it to be cancelled @@ -70,13 +71,45 @@ public @interface Inject { public boolean cancellable() default false; /** - * Set to true to allow local variables to be captured from the target - * method as well as method parameters. + * Specifies the local variable capture behaviour for this injector. * - * @return true if the injector should capture local variables in the frame - * at the injection point + *

When capturing local variables in scope, the variables are appended to + * the callback invocation after the {@link CallbackInfo} argument.

+ * + *

Capturing local variables from the target scope requires careful + * planning because unlike other aspects of an injection (such as the target + * method name and signature), the local variable table is not safe + * from modification by other transformers which may be in use in the + * production environment. Even other injectors which target the same target + * method have the ability to modify the local variable table and thus it is + * in no way safe to assume that local variables in scope at development + * time will be so in production.

+ * + *

To provide some level of flexibility, especially where changes can be + * anticipated (for example a well-known mod makes changes which result in a + * particular structure for the local variable table) it is possible to + * provide overloads for the handler method which will become + * surrogate targets for the orphaned injector by annotating them with an + * {@link Surrogate} annotation.

+ * + *

It is also important to nominate the failure behaviour to follow when + * local capture fails and so all {@link LocalCapture} behaviours which + * specify a capture action imply a particular behaviour for handling + * failure. See the javadoc on the {@link LocalCapture} members for more + * details.

+ * + *

Determining what local variables are available to you and in what + * order can be somewhat tricky, and so a simple mechanism for enumerating + * available locals is provided. By setting locals to + * {@link LocalCapture#PRINT}, the injector writes the local capture state + * to STDERR instead of injecting the callback. Using the output thus + * obtained it is then a straightforward matter of altering the callback + * method signature to match the signature proposed by the Callback + * Injector.

+ * + * @return the desired local capture behaviour for this injector */ -// public boolean captureLocals() default false; + public LocalCapture locals() default LocalCapture.NO_CAPTURE; /** diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/InjectionError.java b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionError.java new file mode 100644 index 00000000..4d9fda1d --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/InjectionError.java @@ -0,0 +1,54 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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; + + +/** + * Error to throw for critical injection problems + */ +public class InjectionError extends Error { + + private static final long serialVersionUID = 1L; + + public InjectionError() { + } + + public InjectionError(String message) { + super(message); + } + + public InjectionError(Throwable cause) { + super(cause); + } + + public InjectionError(String message, Throwable cause) { + super(message, cause); + } + + public InjectionError(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/Surrogate.java b/src/main/java/org/spongepowered/asm/mixin/injection/Surrogate.java new file mode 100644 index 00000000..134c147a --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/Surrogate.java @@ -0,0 +1,41 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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; + + +/** + * Annotation used to decorate surrogate injector methods. See + * {@link Inject#locals()} for information. + */ +@Target({ ElementType.METHOD }) +@Retention(RetentionPolicy.RUNTIME) +public @interface Surrogate { + +} 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 066da61e..57ed1527 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 @@ -24,8 +24,11 @@ */ package org.spongepowered.asm.mixin.injection.callback; +import java.util.ArrayList; import java.util.List; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.tree.AbstractInsnNode; @@ -36,16 +39,21 @@ 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.MethodNode; import org.objectweb.asm.tree.TypeInsnNode; import org.objectweb.asm.tree.VarInsnNode; +import org.spongepowered.asm.mixin.injection.InjectionError; import org.spongepowered.asm.mixin.injection.InjectionPoint; import org.spongepowered.asm.mixin.injection.InvalidInjectionException; +import org.spongepowered.asm.mixin.injection.Surrogate; 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; +import org.spongepowered.asm.util.PrettyPrinter; +import org.spongepowered.asm.util.SignaturePrinter; /** * This class is responsible for generating the bytecode for injected callbacks @@ -68,9 +76,14 @@ public class CallbackInjector extends Injector { final AbstractInsnNode node; /** - * Inflected local variable types + * Calculated local variables */ - final Type[] locals; + final LocalVariableNode[] locals; + + /** + * Local variable types + */ + final Type[] localTypes; /** * The initial frame size based on the target method's arguments @@ -89,9 +102,21 @@ public class CallbackInjector extends Injector { final boolean isAtReturn; /** - * Callback descriptor based on the target method and current context + * Callback descriptor without locals */ - final String descriptor; + final String desc; + + /** + * Callback descriptor with locals + */ + final String descl; + + /** + * Callback argument names, unlike the locals arrays this array does not + * contain null entries for TOP slots, so each index in this array + * matches the corresponding argument index in the callback + */ + final String[] argNames; /** * These two variables keep track of the (additional) stack size @@ -113,17 +138,36 @@ public class CallbackInjector extends Injector { */ final int marshallVar; - Callback(Target target, final AbstractInsnNode node, final Type[] locals) { + Callback(Target target, final AbstractInsnNode node, final LocalVariableNode[] locals, boolean captureLocals) { this.target = target; this.node = node; this.locals = locals; - + this.localTypes = locals != null ? new Type[locals.length] : null; this.frameSize = ASMHelper.getFirstNonArgLocalIndex(target.arguments, !CallbackInjector.this.isStatic()); - this.canCaptureLocals = CallbackInjector.this.captureLocals && locals != null && locals.length > this.frameSize; - this.isAtReturn = this.node instanceof InsnNode && this.isValueReturnOpcode(this.node.getOpcode()); - this.descriptor = target.getCallbackDescriptor(this.canCaptureLocals, locals, target.arguments, this.frameSize); + List argNames = null; + + if (locals != null) { + argNames = new ArrayList(); + for (int l = 0; l <= locals.length; l++) { + if (l == this.frameSize) { + argNames.add(target.returnType == Type.VOID_TYPE ? "ci" : "cir"); + } + if (l < locals.length && locals[l] != null) { + this.localTypes[l] = Type.getType(locals[l].desc); + if (l > 0) { + argNames.add(locals[l].name); + } + } + } + } - this.invoke = target.arguments.length + (this.canCaptureLocals ? locals.length - this.frameSize : 0); + this.argNames = argNames != null ? argNames.toArray(new String[argNames.size()]) : null; + this.canCaptureLocals = captureLocals && locals != null && locals.length > this.frameSize; + this.isAtReturn = this.node instanceof InsnNode && this.isValueReturnOpcode(this.node.getOpcode()); + this.desc = target.getCallbackDescriptor(false, this.localTypes, target.arguments, this.frameSize); + this.descl = target.getCallbackDescriptor(true, this.localTypes, target.arguments, this.frameSize); + + this.invoke = target.arguments.length + (this.canCaptureLocals ? this.localTypes.length - this.frameSize : 0); this.marshallVar = target.method.maxLocals++; } @@ -137,6 +181,10 @@ public class CallbackInjector extends Injector { private boolean isValueReturnOpcode(int opcode) { return opcode >= Opcodes.IRETURN && opcode < Opcodes.RETURN; } + + String getDescriptor() { + return this.canCaptureLocals ? this.descl : this.desc; + } /** * Add an instruction to this callback and increment the appropriate @@ -162,29 +210,30 @@ public class CallbackInjector extends Injector { } } + private final Logger logger = LogManager.getLogger("mixin"); + /** * True if cancellable */ - protected final boolean cancellable; + private final boolean cancellable; /** - * True if capturing locals + * Local variable capture behaviour */ - protected final boolean captureLocals; - + private final LocalCapture localCapture; + /** * Make a new CallbackInjector with the supplied args * * @param info information about this injector * @param cancellable True if injections performed by this injector should * be cancellable - * @param captureLocals True to capture local variables from the frame at - * the target location + * @param localCapture Local variable capture behaviour */ - public CallbackInjector(InjectionInfo info, boolean cancellable, boolean captureLocals) { + public CallbackInjector(InjectionInfo info, boolean cancellable, LocalCapture localCapture) { super(info); this.cancellable = cancellable; - this.captureLocals = captureLocals; + this.localCapture = localCapture; } /* (non-Javadoc) @@ -215,22 +264,13 @@ public class CallbackInjector extends Injector { */ @Override protected void inject(Target target, AbstractInsnNode node) { - Type[] localTypes = null; + LocalVariableNode[] locals = 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); - } - } - } + if (this.localCapture.isCaptureLocals() || this.localCapture.isPrintLocals()) { + locals = Locals.getLocalsAt(this.classNode, target.method, node); } - this.inject(new Callback(target, node, localTypes)); + this.inject(new Callback(target, node, locals, this.localCapture.isCaptureLocals())); } /** @@ -239,18 +279,131 @@ public class CallbackInjector extends Injector { * @param callback callback handle */ private void inject(final Callback callback) { - if (!callback.descriptor.equals(this.methodNode.desc)) { - throw new InvalidInjectionException(this.info, "Invalid descriptor on callback: expected " + callback.descriptor - + " found " + this.methodNode.desc); + if (this.localCapture.isPrintLocals()) { + this.printLocals(callback); + return; + } + + // The actual callback method, to start with this is set to the handler + // method but we will redirect to our generated handler if the signature + // is invalid and we have to generate an error handler stub method + MethodNode callbackMethod = this.methodNode; + + if (!callback.getDescriptor().equals(this.methodNode.desc)) { + + if (callback.canCaptureLocals) { + // First check whether there is a compatible method in the class + // the method must have an identical name and an appropriate + // signature for the current locals. This allows silent failover + // if changes to the local variable table are EXPECTED for some + // reason. + MethodNode handler = ASMHelper.findMethod(this.classNode, this.methodNode.name, callback.getDescriptor()); + if (handler != null && ASMHelper.getVisibleAnnotation(handler, Surrogate.class) != null) { + // Found a matching method, use it + callbackMethod = handler; + } else { + // No matching method, generate a message to bitch about it + String message = this.generateBadLVTMessage(callback); + + switch (this.localCapture) { + case CAPTURE_FAILEXCEPTION: + this.logger.error("Injection error: {}", message); + callbackMethod = this.generateErrorMethod(callback, "org/spongepowered/asm/mixin/injection/InjectionError", message); + break; + case CAPTURE_FAILSOFT: + this.logger.warn("Injection warning: {}", message); + return; + default: + this.logger.error("Critical injection failure: {}", message); + throw new InjectionError(message); + } + } + } else { + throw new InvalidInjectionException(this.info, "Invalid descriptor on callback: expected " + callback.getDescriptor() + + " but found " + this.methodNode.desc); + } } this.createCallbackInfo(callback); - this.invokeCallback(callback); + this.invokeCallback(callback, callbackMethod); this.injectCancellationCode(callback); callback.inject(); } + /** + * Generate the "bad local variable table" message + * + * @param callback callback handle + * @return generated message + */ + private String generateBadLVTMessage(final Callback callback) { + List expected = CallbackInjector.summariseLocals(this.methodNode.desc, callback.target.arguments.length + 1); + List found = CallbackInjector.summariseLocals(callback.localTypes, callback.frameSize); + String message = String.format("Local variable table in %s::%s has incompatible changes. Expected %s but found %s. Callback %s%s", + this.classNode.name.replace('/', '.'), callback.target.method.name, expected, found, this.methodNode.name, this.methodNode.desc); + return message; + } + + /** + * Generates a method which throws an error + * + * @param callback callback handle + * @param errorClass error class to throw + * @param message message for the error + * @return generated method + */ + private MethodNode generateErrorMethod(Callback callback, String errorClass, String message) { + MethodNode method = this.info.addMethod(this.methodNode.access, this.methodNode.name + "$missing", callback.getDescriptor()); + method.maxLocals = ASMHelper.getFirstNonArgLocalIndex(Type.getArgumentTypes(callback.getDescriptor()), !this.isStatic); + method.maxStack = 3; + InsnList insns = method.instructions; + insns.add(new TypeInsnNode(Opcodes.NEW, errorClass)); + insns.add(new InsnNode(Opcodes.DUP)); + insns.add(new LdcInsnNode(message)); + insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, errorClass, "", "(Ljava/lang/String;)V", false)); + insns.add(new InsnNode(Opcodes.ATHROW)); + return method; + } + + /** + * Pretty-print local variable information to stderr + * + * @param callback callback handle + */ + private void printLocals(final Callback callback) { + Type[] args = Type.getArgumentTypes(callback.descl); + SignaturePrinter methodSig = new SignaturePrinter(callback.target.method, callback.argNames); + SignaturePrinter handlerSig = new SignaturePrinter(this.methodNode.name, callback.target.returnType, args, callback.argNames); + handlerSig.setModifiers(this.methodNode); + + PrettyPrinter printer = new PrettyPrinter(); + printer.add("%20s : %s", "Target Class", this.classNode.name.replace('/', '.')); + printer.add("%20s : %s", "Target Method", methodSig); + printer.add("%20s : %d", "Target Max LOCALS", callback.target.maxLocals); + printer.add("%20s : %d", "Initial Frame Size", callback.frameSize); + printer.add("%20s : %s", "Callback Name", this.methodNode.name); + printer.add("%20s : %s %s", "Instruction", callback.node.getClass().getSimpleName(), ASMHelper.getOpcodeName(callback.node.getOpcode())); + printer.hr(); + if (callback.locals.length > callback.frameSize) { + printer.add(" LOCAL TYPE NAME"); + for (int l = 0; l < callback.locals.length; l++) { + String marker = l == callback.frameSize ? ">" : " "; + if (callback.locals[l] != null) { + printer.add("%s [%3d] %20s %-50s %s", marker, l, SignaturePrinter.getTypeName(callback.localTypes[l], false), + callback.locals[l].name, l >= callback.frameSize ? "" : ""); + } else { + boolean isTop = l > 0 && callback.localTypes[l - 1] != null && callback.localTypes[l - 1].getSize() > 1; + printer.add("%s [%3d] %20s", marker, l, isTop ? "" : "-"); + } + } + printer.hr(); + } + printer.add().add("/**").add(" * Expected callback signature").add(" * /"); + printer.add("%s {", handlerSig); + printer.add(" // Method body").add("}").add().print(System.err); + } + /** * @param callback callback handle */ @@ -301,7 +454,7 @@ public class CallbackInjector extends Injector { /** * @param callback callback handle */ - private void invokeCallback(final Callback callback) { + private void invokeCallback(final Callback callback, final MethodNode callbackMethod) { // Push "this" onto the stack if the callback is not static if (!this.isStatic) { callback.add(new VarInsnNode(Opcodes.ALOAD, 0)); @@ -315,11 +468,11 @@ public class CallbackInjector extends Injector { // (Maybe) push the locals onto the stack if (callback.canCaptureLocals) { - Locals.loadLocals(callback.locals, callback, callback.frameSize); + Locals.loadLocals(callback.localTypes, callback, callback.frameSize); } // Call the callback! - this.invokeHandler(callback); + this.invokeMethod(callback, callbackMethod); } /** @@ -377,4 +530,20 @@ public class CallbackInjector extends Injector { protected boolean isStatic() { return this.isStatic; } + + private static List summariseLocals(String desc, int pos) { + return CallbackInjector.summariseLocals(Type.getArgumentTypes(desc), pos); + } + + private static List summariseLocals(Type[] locals, int pos) { + List list = new ArrayList(); + if (locals != null) { + for (; pos < locals.length; pos++) { + if (locals[pos] != null) { + list.add(locals[pos].toString()); + } + } + } + return list; + } } diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/callback/LocalCapture.java b/src/main/java/org/spongepowered/asm/mixin/injection/callback/LocalCapture.java new file mode 100644 index 00000000..f47bdc56 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/injection/callback/LocalCapture.java @@ -0,0 +1,92 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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.callback; + + +/** + * Specifies the behaviour for capturing local variables at an injection point. + * + *

Since local capture relies on calculating the local variable table for the + * target method it is disabled by default for performance reasons. When + * capturing is enabled, local variables are passed to the handler method after + * the {@link CallbackInfo} argument. Since it is entirely possible for another + * transformer to make an incompatible change to the the local variable table at + * run time, the purpose of this enum is to specify the behaviour for local + * capture and the type of recovery to be performed when an incompatible change + * is detected.

+ */ +public enum LocalCapture { + + /** + * Do not capture locals, this is the default behaviour + */ + NO_CAPTURE(false, false), + + /** + * Do not capture locals. Print the expected method signature to stderr + * instead. + */ + PRINT(false, true), + + /** + * Capture locals. If the calculated locals are different from the expected + * values, log a warning and skip this injection. + */ + CAPTURE_FAILSOFT, + + /** + * Capture locals. If the calculated locals are different from the expected + * values, throw an {@link Error}. + */ + CAPTURE_FAILHARD, + + /** + * Capture locals. If the calculated locals are different from the expected + * values, generate a method stub containing an exception. This will allow + * normal execution to continue unless the callback is encountered. + */ + CAPTURE_FAILEXCEPTION; + + private final boolean captureLocals; + + private final boolean printLocals; + + private LocalCapture() { + this(true, false); + } + + private LocalCapture(boolean captureLocals, boolean printLocals) { + this.captureLocals = captureLocals; + this.printLocals = printLocals; + } + + boolean isCaptureLocals() { + return this.captureLocals; + } + + boolean isPrintLocals() { + return this.printLocals; + } +} 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 81e13d52..7bc95417 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 @@ -148,9 +148,13 @@ public abstract class Injector { * @param insns Instruction list to inject into */ protected void invokeHandler(InsnList insns) { - boolean isPrivate = (this.methodNode.access & Opcodes.ACC_PRIVATE) != 0; + this.invokeMethod(insns, this.methodNode); + } + + protected void invokeMethod(InsnList insns, MethodNode methodNode) { + boolean isPrivate = (methodNode.access & Opcodes.ACC_PRIVATE) != 0; int invokeOpcode = this.isStatic ? Opcodes.INVOKESTATIC : isPrivate ? Opcodes.INVOKESPECIAL : Opcodes.INVOKEVIRTUAL; - insns.add(new MethodInsnNode(invokeOpcode, this.classNode.name, this.methodNode.name, this.methodNode.desc, false)); + insns.add(new MethodInsnNode(invokeOpcode, this.classNode.name, methodNode.name, methodNode.desc, false)); } protected static String printArgs(Type[] args) { 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 7b111a51..3d632c3b 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 @@ -27,6 +27,7 @@ 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.callback.LocalCapture; import org.spongepowered.asm.mixin.injection.code.Injector; import org.spongepowered.asm.mixin.transformer.MixinTargetContext; import org.spongepowered.asm.util.ASMHelper; @@ -40,8 +41,8 @@ public class CallbackInjectionInfo extends InjectionInfo { @Override protected Injector initInjector(AnnotationNode injectAnnotation) { boolean cancellable = ASMHelper.getAnnotationValue(injectAnnotation, "cancellable", false); - boolean captureLocals = ASMHelper.getAnnotationValue(injectAnnotation, "captureLocals", false); + LocalCapture locals = ASMHelper.getAnnotationValue(injectAnnotation, "locals", LocalCapture.class, LocalCapture.NO_CAPTURE); - return new CallbackInjector(this, cancellable, captureLocals); + 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 c1d18624..9518f945 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 @@ -30,6 +30,7 @@ import java.util.Collection; import java.util.Deque; import java.util.List; +import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.AnnotationNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.MethodNode; @@ -90,6 +91,11 @@ public abstract class InjectionInfo { */ protected Injector injector; + /** + * Methods injected by injectors + */ + private final List injectedMethods = new ArrayList(0); + /** * ctor * @@ -179,6 +185,15 @@ public abstract class InjectionInfo { } } + /** + * Perform cleanup and post-injection tasks + */ + public void postInject() { + for (MethodNode method : this.injectedMethods) { + this.classNode.methods.add(method); + } + } + /** * Get the mixin target context for this injection * @@ -224,6 +239,21 @@ public abstract class InjectionInfo { return this.targets; } + /** + * Inject a method into the target class + * + * @param access + * @param name + * @param desc + * + * @return new method + */ + public MethodNode addMethod(int access, String name, String desc) { + MethodNode method = new MethodNode(Opcodes.ASM5, access | Opcodes.ACC_SYNTHETIC, name, desc, null, null); + this.injectedMethods.add(method); + return method; + } + /** * Finds methods in the target class which match searchFor * diff --git a/src/main/java/org/spongepowered/asm/mixin/injection/struct/Target.java b/src/main/java/org/spongepowered/asm/mixin/injection/struct/Target.java index 91ea6d7f..301598f7 100644 --- a/src/main/java/org/spongepowered/asm/mixin/injection/struct/Target.java +++ b/src/main/java/org/spongepowered/asm/mixin/injection/struct/Target.java @@ -118,7 +118,7 @@ public class Target { * @return generated descriptor */ public String getCallbackDescriptor(final boolean captureLocals, final Type[] locals, Type[] argumentTypes, int startIndex) { - if (!captureLocals) { + if (!captureLocals || locals == null) { return this.callbackDescriptor; } diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java index 82547492..e3b83b8f 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTransformer.java @@ -916,6 +916,8 @@ public class MixinTransformer extends TreeTransformer { * @param mixin */ private void applyInjections(ClassNode targetClass, MixinTargetContext mixin) { + List injected = new ArrayList(); + for (MethodNode method : targetClass.methods) { InjectionInfo injectInfo = InjectionInfo.parse(mixin, method); if (injectInfo == null) { @@ -924,10 +926,15 @@ public class MixinTransformer extends TreeTransformer { if (injectInfo.isValid()) { injectInfo.inject(); + injected.add(injectInfo); } method.visibleAnnotations.remove(injectInfo.getAnnotation()); } + + for (InjectionInfo injectInfo : injected) { + injectInfo.postInject(); + } } /** diff --git a/src/main/java/org/spongepowered/asm/util/ASMHelper.java b/src/main/java/org/spongepowered/asm/util/ASMHelper.java index 1a432c3d..9c9ed2d8 100644 --- a/src/main/java/org/spongepowered/asm/util/ASMHelper.java +++ b/src/main/java/org/spongepowered/asm/util/ASMHelper.java @@ -425,7 +425,7 @@ public class ASMHelper { } } - return String.valueOf(opcode); + return opcode >= 0 ? String.valueOf(opcode) : ""; } /** diff --git a/src/main/java/org/spongepowered/asm/util/Locals.java b/src/main/java/org/spongepowered/asm/util/Locals.java index 0e8d7874..fde6fff1 100644 --- a/src/main/java/org/spongepowered/asm/util/Locals.java +++ b/src/main/java/org/spongepowered/asm/util/Locals.java @@ -119,10 +119,17 @@ public class Locals { */ public static LocalVariableNode[] getLocalsAt(ClassNode classNode, MethodNode method, AbstractInsnNode node) { LocalVariableNode[] frame = new LocalVariableNode[method.maxLocals]; + int local = 0, index = 0; // Initialise implicit "this" reference in non-static methods if ((method.access & Opcodes.ACC_STATIC) == 0) { - frame[0] = new LocalVariableNode("this", classNode.name, null, null, null, 0); + frame[local++] = new LocalVariableNode("this", classNode.name, null, null, null, 0); + } + + // Initialise method arguments + for (Type argType : Type.getArgumentTypes(method.desc)) { + frame[local] = new LocalVariableNode("arg" + index++, argType.toString(), null, null, null, local); + local += argType.getSize(); } for (Iterator iter = method.instructions.iterator(); iter.hasNext();) { diff --git a/src/main/java/org/spongepowered/asm/util/PrettyPrinter.java b/src/main/java/org/spongepowered/asm/util/PrettyPrinter.java new file mode 100644 index 00000000..5eae20db --- /dev/null +++ b/src/main/java/org/spongepowered/asm/util/PrettyPrinter.java @@ -0,0 +1,109 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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.util; + +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.List; + +import com.google.common.base.Strings; + + +/** + * Prints information in a pretty box + */ +public class PrettyPrinter { + + /** + * "Horizontal rule" marker + */ + private static final String HR = "---"; + + /** + * Box with (adapts to contents) + */ + private int width = 100; + + /** + * Content lines + */ + private final List lines = new ArrayList(); + + /** + * Adds a blank line to the output + * + * @return fluent interface + */ + public PrettyPrinter add() { + this.lines.add(""); + return this; + } + + /** + * Adds a formatted line to the output + * + * @param format format string + * @param args arguments + * + * @return fluent interface + */ + public PrettyPrinter add(String format, Object... args) { + String line = String.format(format, args); + this.lines.add(line); + this.width = Math.max(this.width, line.length()); + return this; + } + + /** + * Adds a horizontal rule to the output + * + * @return fluent interface + */ + public PrettyPrinter hr() { + this.lines.add(PrettyPrinter.HR); + return this; + } + + /** + * Print this printer to the specified output + * + * @param stream stream to print to + */ + public void print(PrintStream stream) { + this.printHr(stream); + for (String line : this.lines) { + if (line == PrettyPrinter.HR) { + this.printHr(stream); + } else { + stream.printf("/* %-" + this.width + "s */\n", line); + } + } + this.printHr(stream); + } + + private void printHr(PrintStream stream) { + stream.printf("/*%s*/\n", Strings.repeat("*", this.width + 2)); + } +} diff --git a/src/main/java/org/spongepowered/asm/util/SignaturePrinter.java b/src/main/java/org/spongepowered/asm/util/SignaturePrinter.java new file mode 100644 index 00000000..ecf2e81c --- /dev/null +++ b/src/main/java/org/spongepowered/asm/util/SignaturePrinter.java @@ -0,0 +1,195 @@ +/* + * This file is part of Sponge, licensed under the MIT License (MIT). + * + * Copyright (c) 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.util; + +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; +import org.objectweb.asm.tree.LocalVariableNode; +import org.objectweb.asm.tree.MethodNode; + +import com.google.common.base.Strings; + + +/** + * Generates callback signature for callback pretty-print + */ +public class SignaturePrinter { + + /** + * Method name + */ + private final String name; + + /** + * The return type of the target method (used to fill in the generic + * bound on a CallbackInfoReturnable. + */ + private final Type returnType; + + /** + * Argument type array (sparse, with no TOP entries) + */ + private final Type[] argTypes; + + /** + * Argument names + */ + private final String[] argNames; + + /** + * Method prefix + */ + private String modifiers = "private void"; + + public SignaturePrinter(MethodNode method) { + this(method.name, Type.VOID_TYPE, Type.getArgumentTypes(method.desc)); + this.setModifiers(method); + } + + public SignaturePrinter(MethodNode method, String[] argNames) { + this(method.name, Type.VOID_TYPE, Type.getArgumentTypes(method.desc), argNames); + this.setModifiers(method); + } + + public SignaturePrinter(String name, String desc) { + this(name, Type.getReturnType(desc), Type.getArgumentTypes(desc)); + } + + public SignaturePrinter(String name, Type returnType, Type[] args) { + this.name = name; + this.returnType = returnType; + this.argTypes = new Type[args.length]; + this.argNames = new String[args.length]; + for (int l = 0, v = 0; l < args.length; l++) { + if (args[l] != null) { + this.argTypes[l] = args[l]; + this.argNames[l] = "var" + v++; + } + } + } + + public SignaturePrinter(String name, Type returnType, LocalVariableNode[] args) { + this.name = name; + this.returnType = returnType; + this.argTypes = new Type[args.length]; + this.argNames = new String[args.length]; + for (int l = 0; l < args.length; l++) { + if (args[l] != null) { + this.argTypes[l] = Type.getType(args[l].desc); + this.argNames[l] = args[l].name; + } + } + } + + public SignaturePrinter(String name, Type returnType, Type[] argTypes, String[] argNames) { + this.name = name; + this.returnType = returnType; + this.argTypes = argTypes; + this.argNames = argNames; + } + + public void setModifiers(MethodNode method) { + String returnType = SignaturePrinter.getTypeName(Type.getReturnType(method.desc), false); + if ((method.access & Opcodes.ACC_PUBLIC) != 0) { + this.setModifiers("public " + returnType); + } else if ((method.access & Opcodes.ACC_PROTECTED) != 0) { + this.setModifiers("protected " + returnType); + } else if ((method.access & Opcodes.ACC_PRIVATE) != 0) { + this.setModifiers("private " + returnType); + } else { + this.setModifiers(returnType); + } + } + + public void setModifiers(String modifiers) { + this.modifiers = modifiers; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append(this.modifiers).append(" ").append(this.name).append('('); + for (int var = 0; var < this.argTypes.length; var++) { + if (this.argTypes[var] == null) { + continue; + } else if (var > 0) { + sb.append(", "); + } + String name = Strings.isNullOrEmpty(this.argNames[var]) ? "unnamed" + var : this.argNames[var]; + this.appendType(sb, this.argTypes[var], name); + } + sb.append(")"); + return sb.toString(); + } + + private StringBuilder appendType(StringBuilder sb, Type type, String name) { + switch (type.getSort()) { + case Type.ARRAY: + return this.appendType(sb, type.getElementType(), name).append("[]"); + case Type.OBJECT: + return this.appendType(sb, type.getClassName(), name); + default: + return sb.append(SignaturePrinter.getTypeName(type, false)).append(' ').append(name); + } + } + + private StringBuilder appendType(StringBuilder sb, String typeName, String name) { + typeName = typeName.substring(typeName.lastIndexOf('.') + 1); + sb.append(typeName); + if (typeName.endsWith("CallbackInfoReturnable")) { + sb.append('<').append(SignaturePrinter.getTypeName(this.returnType, true)).append('>'); + } + return sb.append(' ').append(name); + } + + /** + * Get the source code name for the specified type + * + * @param type Type to generate a friendly name for + * @param box True to return the equivalent boxing type for primitives + * @return String representation of the specified type, eg "int" for an + * integer primitive or "String" for java.lang.String + */ + public static String getTypeName(Type type, boolean box) { + switch (type.getSort()) { + case Type.VOID: return box ? "Void" : "void"; + case Type.BOOLEAN: return box ? "Boolean" : "boolean"; + case Type.CHAR: return box ? "Character" : "char"; + case Type.BYTE: return box ? "Byte" : "byte"; + case Type.SHORT: return box ? "Short" : "short"; + case Type.INT: return box ? "Integer" : "int"; + case Type.FLOAT: return box ? "Float" : "float"; + case Type.LONG: return box ? "Long" : "long"; + case Type.DOUBLE: return box ? "Double" : "double"; + case Type.ARRAY: return SignaturePrinter.getTypeName(type.getElementType(), box) + "[]"; + case Type.OBJECT: + String typeName = type.getClassName(); + typeName = typeName.substring(typeName.lastIndexOf('.') + 1); + return typeName; + default: + return "Object"; + } + } +}