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 b7383a5a..066da61e 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 @@ -52,15 +52,125 @@ import org.spongepowered.asm.util.Locals; */ public class CallbackInjector extends Injector { + /** + * Struct to replace all the horrible state variables from before + */ + private class Callback extends InsnList { + + /** + * Target method handle + */ + final Target target; + + /** + * Target node, callback injected before this node + */ + final AbstractInsnNode node; + + /** + * Inflected local variable types + */ + final Type[] locals; + + /** + * The initial frame size based on the target method's arguments + */ + final int frameSize; + + /** + * True if the injector is set to capture locals and we acutally can + * capture the locals (have sufficient info etc.) + */ + final boolean canCaptureLocals; + + /** + * True if the target insn is a RETURN opcode + */ + final boolean isAtReturn; + + /** + * Callback descriptor based on the target method and current context + */ + final String descriptor; + + /** + * These two variables keep track of the (additional) stack size + * required for the two actions we're going to be injecting insns to + * perform, namely calling the CallbackInfo ctor, and then invoking the + * callback itself. When we get to the end of this injection we will + * then set the MAXS value on the target method to its original value + * plus the larger of the two values. + */ + int ctor, invoke; + + /** + * Marshall var is the local where we marshall the utility references we + * need during invoke of the callback, those being the current return + * value for value-return scenarios (we store the topmost stack entry + * and then push it into the ctor of the CallbackInfo) and also the + * CallbackInfo reference itself (we use the same local var for these + * two purposes because they don't exist at the same time). + */ + final int marshallVar; + + Callback(Target target, final AbstractInsnNode node, final Type[] locals) { + this.target = target; + this.node = node; + this.locals = locals; + + 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); + + this.invoke = target.arguments.length + (this.canCaptureLocals ? locals.length - this.frameSize : 0); + this.marshallVar = target.method.maxLocals++; + } + + /** + * Returns true if the supplied opcode represents a non-void + * RETURN opcode + * + * @param opcode opcode to check + * @return true if value return + */ + private boolean isValueReturnOpcode(int opcode) { + return opcode >= Opcodes.IRETURN && opcode < Opcodes.RETURN; + } + + /** + * Add an instruction to this callback and increment the appropriate + * stack sizes + * + * @param insn Instruction to append + * @param ctorStack true if this insn contributes to the ctor stack + * @param invokeStack true if this insn contributes to the invoke stack + */ + void add(AbstractInsnNode insn, boolean ctorStack, boolean invokeStack) { + this.add(insn); + this.ctor += (ctorStack ? 1 : 0); + this.invoke += (invokeStack ? 1 : 0); + } + + /** + * Inject our generated code into the method and set the max stack size + * for the method based on our calculated values + */ + void inject() { + this.target.method.instructions.insertBefore(this.node, this); + this.target.method.maxStack = Math.max(this.target.method.maxStack, this.target.maxStack + Math.max(this.invoke, this.ctor)); + } + } + /** * True if cancellable */ - private final boolean cancellable; + protected final boolean cancellable; /** * True if capturing locals */ - private final boolean captureLocals; + protected final boolean captureLocals; /** * Make a new CallbackInjector with the supplied args @@ -120,167 +230,151 @@ public class CallbackInjector extends Injector { } } - this.inject(target, node, localTypes); + this.inject(new Callback(target, node, localTypes)); } /** * Generate the actual bytecode for the callback * - * @param target Target method to inject callback into - * @param node Target node within - * @param locals Inferred local types at the target location + * @param callback callback handle */ - 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); - - // Work out whether we have enough info to capture locals in this scenario - boolean doCaptureLocals = this.captureLocals && locals != null && locals.length > initialFrameSize; - - // Determine the descriptor for the callback based on the target method and current context - String callbackDescriptor = target.getCallbackDescriptor(doCaptureLocals, locals, target.arguments, initialFrameSize); - - // If it doesn't match, then cry - if (!callbackDescriptor.equals(this.methodNode.desc)) { - throw new InvalidInjectionException(this.info, "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, - // namely calling the CallbackInfo ctor, and then invoking the callback itself. When we get to the end of this injection we will then set - // the MAXS value on the target method to its original value plus the larger of the two values. - int ctorMAXS = 0; - int invokeMAXS = target.arguments.length + (doCaptureLocals ? locals.length - initialFrameSize : 0); - - // Marshall var is the local where we marshall the utility references we need during invoke of the callback, those being the current return - // value for value-return scenarios (we store the topmost stack entry and then push it into the ctor of the CallbackInfo) and also the - // CallbackInfo reference itself (we use the same local var for these two purposes because they don't exist at the same time). - int marshallVar = target.method.maxLocals++; - - // Insns we will inject - InsnList insns = new InsnList(); - - // Assume (for now) that we won't push the return value into the CallbackInfo ctor - boolean pushReturnValue = false; - - // 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 (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)); - } - - // CHECKSTYLE:OFF - // Instance the EventInfo for this event - insns.add(new TypeInsnNode(Opcodes.NEW, target.callbackInfoClass)); ctorMAXS++; - insns.add(new InsnNode(Opcodes.DUP)); ctorMAXS++; invokeMAXS++; - // CHECKSTYLE:ON - ctorMAXS += this.invokeCallbackInfoCtor(target, insns, pushReturnValue, marshallVar); - insns.add(new VarInsnNode(Opcodes.ASTORE, marshallVar)); - - // Push "this" onto the stack if the callback is not static - if (!this.isStatic) { - insns.add(new VarInsnNode(Opcodes.ALOAD, 0)); - } - - // Push the target method's parameters onto the stack - ASMHelper.loadArgs(target.arguments, insns, this.isStatic ? 0 : 1); - - // Push the callback info onto the stack - insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar)); - - // (Maybe) push the locals onto the stack - if (doCaptureLocals) { - Locals.loadLocals(locals, insns, initialFrameSize); + 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); } - // Call the callback! - this.invokeHandler(insns); - - if (this.cancellable) { - // Inject the if (e.isCancelled()) return e.getReturnValue(); - this.injectCancellationCode(target, insns, node, marshallVar); - } - - // Inject our generated code into the method - target.method.instructions.insertBefore(node, insns); - target.method.maxStack = Math.max(target.method.maxStack, Math.max(target.maxStack + ctorMAXS, target.maxStack + invokeMAXS)); + this.createCallbackInfo(callback); + this.invokeCallback(callback); + this.injectCancellationCode(callback); + + callback.inject(); } /** - * @param target target method - * @param insns instruction list to append to - * @param pushReturnValue True to push the current value on the stack into - * the CallbackInfo ctor, used when injecting at a RETURN opcode in - * order to capture the current return value - * @param marshallVar "working" variable used to marshallt temporary values - * @return additional MAXS slots required + * @param callback callback handle */ - protected int invokeCallbackInfoCtor(Target target, InsnList insns, boolean pushReturnValue, int marshallVar) { - int ctorMAXS = 0; + private void createCallbackInfo(final Callback callback) { + this.dupReturnValue(callback); - // CHECKSTYLE:OFF - insns.add(new LdcInsnNode(target.method.name)); ctorMAXS++; - insns.add(new InsnNode(this.cancellable ? Opcodes.ICONST_1 : Opcodes.ICONST_0)); ctorMAXS++; - // CHECKSTYLE:ON + callback.add(new TypeInsnNode(Opcodes.NEW, callback.target.callbackInfoClass), true, false); + callback.add(new InsnNode(Opcodes.DUP), true, true); + + this.invokeCallbackInfoCtor(callback); + callback.add(new VarInsnNode(Opcodes.ASTORE, callback.marshallVar)); + } - if (pushReturnValue) { - insns.add(new VarInsnNode(target.returnType.getOpcode(Opcodes.ILOAD), marshallVar)); - insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, - target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(target.returnType), false)); + /** + * 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 + * + * @param callback callback handle + */ + private void dupReturnValue(final Callback callback) { + if (!callback.isAtReturn) { + return; + } + + callback.add(new InsnNode(Opcodes.DUP)); + callback.add(new VarInsnNode(callback.target.returnType.getOpcode(Opcodes.ISTORE), callback.marshallVar)); + } + + /** + * @param callback callback handle + */ + protected void invokeCallbackInfoCtor(final Callback callback) { + callback.add(new LdcInsnNode(callback.target.method.name), true, false); + callback.add(new InsnNode(this.cancellable ? Opcodes.ICONST_1 : Opcodes.ICONST_0), true, false); + + if (callback.isAtReturn) { + callback.add(new VarInsnNode(callback.target.returnType.getOpcode(Opcodes.ILOAD), callback.marshallVar)); + callback.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, + callback.target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(callback.target.returnType), false)); } else { - insns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, - target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(), false)); + callback.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, + callback.target.callbackInfoClass, Injector.CTOR, CallbackInfo.getConstructorDescriptor(), false)); + } + } + + /** + * @param callback callback handle + */ + private void invokeCallback(final Callback callback) { + // Push "this" onto the stack if the callback is not static + if (!this.isStatic) { + callback.add(new VarInsnNode(Opcodes.ALOAD, 0)); } - return ctorMAXS; + // Push the target method's parameters onto the stack + ASMHelper.loadArgs(callback.target.arguments, callback, this.isStatic ? 0 : 1); + + // Push the callback info onto the stack + callback.add(new VarInsnNode(Opcodes.ALOAD, callback.marshallVar)); + + // (Maybe) push the locals onto the stack + if (callback.canCaptureLocals) { + Locals.loadLocals(callback.locals, callback, callback.frameSize); + } + + // Call the callback! + this.invokeHandler(callback); } /** * if (e.isCancelled()) return e.getReturnValue(); * - * @param target target method - * @param insns instruction list to append to - * @param node target node - * @param marshallVar "working" variable used to marshallt temporary values + * @param callback callback handle */ - 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(), + protected void injectCancellationCode(final Callback callback) { + if (!this.cancellable) { + return; + } + + callback.add(new VarInsnNode(Opcodes.ALOAD, callback.marshallVar)); + callback.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, callback.target.callbackInfoClass, CallbackInfo.getIsCancelledMethodName(), CallbackInfo.getIsCancelledMethodSig(), false)); LabelNode notCancelled = new LabelNode(); - insns.add(new JumpInsnNode(Opcodes.IFEQ, notCancelled)); + callback.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, node, marshallVar); + // If this is a void method, just injects a RETURN opcode, otherwise we + // need to get the return value from the EventInfo + this.injectReturnCode(callback); - insns.add(notCancelled); + callback.add(notCancelled); } /** * Inject the appropriate return code for the method type * - * @param target target method - * @param insns instruction list to append to - * @param node target node - * @param marshallVar "working" variable used to marshallt temporary values + * @param callback callback handle */ - protected void injectReturnCode(Target target, final InsnList insns, final AbstractInsnNode node, int marshallVar) { - if (target.returnType.equals(Type.VOID_TYPE)) { + protected void injectReturnCode(final Callback callback) { + if (callback.target.returnType.equals(Type.VOID_TYPE)) { // Void method, so just return void - insns.add(new InsnNode(Opcodes.RETURN)); + callback.add(new InsnNode(Opcodes.RETURN)); } else { - // Non-void method, so work out which accessor to call to get the return value, and return it - insns.add(new VarInsnNode(Opcodes.ALOAD, marshallVar)); - String accessor = CallbackInfoReturnable.getReturnAccessor(target.returnType); - String descriptor = CallbackInfoReturnable.getReturnDescriptor(target.returnType); - insns.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, target.callbackInfoClass, accessor, descriptor, false)); - if (target.returnType.getSort() == Type.OBJECT) { - insns.add(new TypeInsnNode(Opcodes.CHECKCAST, target.returnType.getInternalName())); + // Non-void method, so work out which accessor to call to get the + // return value, and return it + callback.add(new VarInsnNode(Opcodes.ALOAD, callback.marshallVar)); + String accessor = CallbackInfoReturnable.getReturnAccessor(callback.target.returnType); + String descriptor = CallbackInfoReturnable.getReturnDescriptor(callback.target.returnType); + callback.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, callback.target.callbackInfoClass, accessor, descriptor, false)); + if (callback.target.returnType.getSort() == Type.OBJECT) { + callback.add(new TypeInsnNode(Opcodes.CHECKCAST, callback.target.returnType.getInternalName())); } - insns.add(new InsnNode(target.returnType.getOpcode(Opcodes.IRETURN))); + callback.add(new InsnNode(callback.target.returnType.getOpcode(Opcodes.IRETURN))); } } + + /** + * Explicit to avoid creation of synthetic accessor + * + * @return true if the target method is static + */ + protected boolean isStatic() { + return this.isStatic; + } }