From e51a2dd28830a9068b2f30531873975bc8d73452 Mon Sep 17 00:00:00 2001 From: BenLewis Date: Sun, 11 Oct 2015 10:43:57 +1300 Subject: [PATCH] Fixed style issues and refactored transformConstantNode The refactor is to get rid of code duplication between load constant transform method and handling of invokedynamic arguments. --- .../asm/mixin/transformer/MemberRef.java | 321 ++++++++++++++++++ .../mixin/transformer/MixinTargetContext.java | 271 +++------------ .../org/spongepowered/asm/util/Constants.java | 1 + 3 files changed, 364 insertions(+), 229 deletions(-) create mode 100644 src/main/java/org/spongepowered/asm/mixin/transformer/MemberRef.java diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MemberRef.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MemberRef.java new file mode 100644 index 00000000..570f39d7 --- /dev/null +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MemberRef.java @@ -0,0 +1,321 @@ +/* + * 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.transformer; + +import org.spongepowered.asm.lib.Handle; +import org.spongepowered.asm.lib.Opcodes; +import org.spongepowered.asm.lib.tree.FieldInsnNode; +import org.spongepowered.asm.lib.tree.MethodInsnNode; +import org.spongepowered.asm.util.ASMHelper; + +/** + * Reference to a field or method that also includes invocation + * instructions. + * + * To instances are defined to be equal if they both refer to the same method + * and have the same invocation instructions. + */ +public abstract class MemberRef { + + /** + * A static reference to a method backed by an invoke instruction + */ + public static final class StaticMethodRef extends MemberRef { + + /** + * Method invocation instruction + */ + public final MethodInsnNode insn; + + /** + * ctor + * + * @param insn Method instruction of this member reference + */ + public StaticMethodRef(MethodInsnNode insn) { + this.insn = insn; + } + + @Override + public boolean isField() { + return false; + } + + @Override + public int getOpcode() { + return this.insn.getOpcode(); + } + + @Override + public String getOwner() { + return this.insn.owner; + } + + @Override + public void setOwner(String owner) { + this.insn.owner = owner; + } + + @Override + public String getName() { + return this.insn.name; + } + + @Override + public String getDesc() { + return this.insn.desc; + } + + @Override + public void setDesc(String desc) { + this.insn.desc = desc; + } + } + + /** + * A static reference to a field backed by field get/put instruction + */ + public static final class StaticFieldRef extends MemberRef { + + /** + * Field accessor instruction + */ + public final FieldInsnNode insn; + + /** + * ctor + * + * @param insn Field instruction this member reference + */ + public StaticFieldRef(FieldInsnNode insn) { + this.insn = insn; + } + + @Override + public boolean isField() { + return true; + } + + @Override + public int getOpcode() { + return this.insn.getOpcode(); + } + + @Override + public String getOwner() { + return this.insn.owner; + } + + @Override + public void setOwner(String owner) { + this.insn.owner = owner; + } + + @Override + public String getName() { + return this.insn.name; + } + + @Override + public String getDesc() { + return this.insn.desc; + } + + @Override + public void setDesc(String desc) { + this.insn.desc = desc; + } + } + + /** + * A reference to a field or method backed by a method handle + */ + public static final class HandleRef extends MemberRef { + + private Handle handle; + + /** + * Creates a member reference initially referring to the member referred + * to by the method handle and the invocation instruction of the method + * handle. + * + * @param handle Initial method handle. + */ + public HandleRef(Handle handle) { + this.handle = handle; + } + + /** + * Gets a method handle for the member this is object is referring to. + * + * @return Method handle representing this object + */ + public Handle getMethodHandle() { + return this.handle; + } + + @Override + public boolean isField() { + switch (this.handle.getTag()) { + case Opcodes.H_INVOKEVIRTUAL: + case Opcodes.H_INVOKESTATIC: + case Opcodes.H_INVOKEINTERFACE: + case Opcodes.H_INVOKESPECIAL: + case Opcodes.H_NEWINVOKESPECIAL: + return false; + case Opcodes.H_GETFIELD: + case Opcodes.H_GETSTATIC: + case Opcodes.H_PUTFIELD: + case Opcodes.H_PUTSTATIC: + return true; + default: + throw new MixinTransformerError("Invalid tag " + this.handle.getTag() + " for method handle " + this.handle + "."); + } + } + + @Override + public int getOpcode() { + switch (this.handle.getTag()) { + case Opcodes.H_INVOKEVIRTUAL: + return Opcodes.INVOKEVIRTUAL; + case Opcodes.H_INVOKESTATIC: + return Opcodes.INVOKESTATIC; + case Opcodes.H_INVOKEINTERFACE: + return Opcodes.INVOKEINTERFACE; + case Opcodes.H_INVOKESPECIAL: + case Opcodes.H_NEWINVOKESPECIAL: + return Opcodes.INVOKESPECIAL; + case Opcodes.H_GETFIELD: + return Opcodes.GETFIELD; + case Opcodes.H_GETSTATIC: + return Opcodes.GETSTATIC; + case Opcodes.H_PUTFIELD: + return Opcodes.PUTFIELD; + case Opcodes.H_PUTSTATIC: + return Opcodes.PUTSTATIC; + default: + throw new MixinTransformerError("Invalid tag " + this.handle.getTag() + " for method handle " + this.handle + "."); + } + } + + @Override + public String getOwner() { + return this.handle.getOwner(); + } + + @Override + public void setOwner(String owner) { + this.handle = new Handle(this.handle.getTag(), owner, this.handle.getName(), this.handle.getDesc()); + } + + @Override + public String getName() { + return this.handle.getName(); + } + + @Override + public String getDesc() { + return this.handle.getDesc(); + } + + @Override + public void setDesc(String desc) { + this.handle = new Handle(this.handle.getTag(), this.handle.getOwner(), this.handle.getName(), desc); + } + } + + /** + * Whether this member is a field. + * + * @return If this member is a field, else it is a method + */ + public abstract boolean isField(); + + /** + * The opcode of the invocation. + * + * @return The opcode of the invocation + */ + public abstract int getOpcode(); + + /** + * The internal name for the owner of this member. + * + * @return The owners name + */ + public abstract String getOwner(); + + /** + * Changes the owner of this + * + * @param owner New owner + */ + public abstract void setOwner(String owner); + + /** + * Name of this member. + * + * @return Name of this member. + */ + public abstract String getName(); + + /** + * Descriptor of this member. + * + * @return Descriptor of this member + */ + public abstract String getDesc(); + + /** + * Changes the descriptor of this member + * + * @param desc New descriptor of this member + */ + public abstract void setDesc(String desc); + + @Override + public String toString() { + return ASMHelper.getOpcodeName(this.getOpcode()) + " for " + + this.getOwner() + "." + this.getName() + (this.isField() ? ":" : "") + this.getDesc(); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof MemberRef)) { + return false; + } + + MemberRef other = (MemberRef)obj; + return this.getOpcode() == other.getOpcode() + && this.getOwner().equals(other.getOwner()) + && this.getName().equals(other.getName()) + && this.getDesc().equals(other.getDesc()); + } + + @Override + public int hashCode() { + return this.toString().hashCode(); + } +} diff --git a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java index f31d76d9..3f4af6f4 100644 --- a/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java +++ b/src/main/java/org/spongepowered/asm/mixin/transformer/MixinTargetContext.java @@ -231,9 +231,9 @@ public class MixinTargetContext implements IReferenceMapperContext { AbstractInsnNode insn = iter.next(); if (insn instanceof MethodInsnNode) { - this.transformMethodRef(method, iter, new StaticMethodRef((MethodInsnNode)insn)); + this.transformMethodRef(method, iter, new MemberRef.StaticMethodRef((MethodInsnNode)insn)); } else if (insn instanceof FieldInsnNode) { - this.transformFieldRef(method, iter, new StaticFieldRef((FieldInsnNode)insn)); + this.transformFieldRef(method, iter, new MemberRef.StaticFieldRef((FieldInsnNode)insn)); } else if (insn instanceof TypeInsnNode) { this.transformTypeNode(method, iter, (TypeInsnNode)insn); } else if (insn instanceof LdcInsnNode) { @@ -295,8 +295,8 @@ public class MixinTargetContext implements IReferenceMapperContext { */ private void transformFieldRef(MethodNode method, Iterator iter, MemberRef fieldRef) { if (Constants.IMAGINARY_SUPER.equals(fieldRef.getName())) { - if (fieldRef instanceof StaticFieldRef) { - this.processImaginarySuper(method, ((StaticFieldRef) fieldRef).insn); + if (fieldRef instanceof MemberRef.StaticFieldRef) { + this.processImaginarySuper(method, ((MemberRef.StaticFieldRef) fieldRef).insn); iter.remove(); } else { throw new InvalidMixinException(this.mixin, "Cannot call imaginary super from method handle."); @@ -334,20 +334,15 @@ public class MixinTargetContext implements IReferenceMapperContext { } /** - * Transforms class literals in the method being processed. + * Transforms class literals and method handle loads in the method being + * processed. * * @param method Method being processed * @param iter Insn interator * @param ldcInsn Insn to transform */ private void transformConstantNode(MethodNode method, Iterator iter, LdcInsnNode ldcInsn) { - if (ldcInsn.cst instanceof Type) { - Type type = (Type)ldcInsn.cst; - String desc = this.transformDescriptor(type); - if (!type.toString().equals(desc)) { - ldcInsn.cst = Type.getType(desc); - } - } + ldcInsn.cst = this.transformConstant(method, iter, ldcInsn.cst); } /** @@ -358,233 +353,53 @@ public class MixinTargetContext implements IReferenceMapperContext { * @param dynInsn Insn to transform */ private void transformInvokeDynamicNode(MethodNode method, Iterator iter, InvokeDynamicInsnNode dynInsn) { - // set class version to java 8 - targetClass.version = 52; dynInsn.desc = this.transformMethodDescriptor(dynInsn.desc); dynInsn.bsm = this.transformHandle(method, iter, dynInsn.bsm); for (int i = 0; i < dynInsn.bsmArgs.length; i++) { - Object bsmArg = dynInsn.bsmArgs[i]; - if (bsmArg instanceof Handle) { - dynInsn.bsmArgs[i] = this.transformHandle(method, iter, ((Handle) bsmArg)); - } else if (bsmArg instanceof Type) { - Type type = ((Type) bsmArg); - String desc = this.transformDescriptor(type); - if (!type.toString().equals(desc)) { - dynInsn.bsmArgs[i] = Type.getType(desc); - } - } + dynInsn.bsmArgs[i] = this.transformConstant(method, iter, dynInsn.bsmArgs[i]); } } + /** + * Transforms a constant in the constant pool. + * + * @param method Method being processed + * @param iter Insn interator + * @param constant Consatnt pool entry + * @return Transformed constant + */ + private Object transformConstant(MethodNode method, Iterator iter, Object constant) { + if (constant instanceof Type) { + Type type = (Type)constant; + String desc = this.transformDescriptor(type); + if (!type.toString().equals(desc)) { + return Type.getType(desc); + } else { + return constant; + } + } else if (constant instanceof Handle) { + return this.transformHandle(method, iter, (Handle)constant); + } + return constant; + } + /** * Transforms a method handle that is referenced from the method being * processed. * + * @param method Method being processed + * @param iter Insn interator * @param handle Handle to transform */ private Handle transformHandle(MethodNode method, Iterator iter, Handle handle) { - HandleRef memberRef = new HandleRef(handle); + this.targetClass.version = Constants.JAVA8_CLASSFILE_VERSION; + MemberRef.HandleRef memberRef = new MemberRef.HandleRef(handle); if (memberRef.isField()) { this.transformFieldRef(method, iter, memberRef); } else { this.transformMethodRef(method, iter, memberRef); } - return memberRef.handle; - } - - /** - * Reference to a field or method that also includes invocation - * instructions. - */ - private abstract class MemberRef { - abstract boolean isField(); - - abstract int getOpcode(); - - abstract String getOwner(); - - abstract void setOwner(String owner); - - abstract String getName(); - - abstract String getDesc(); - - abstract void setDesc(String desc); - } - - /** - * A static reference to a method backed by an invoke instruction - */ - private final class StaticMethodRef extends MemberRef { - - private final MethodInsnNode insn; - - private StaticMethodRef(MethodInsnNode insn) { - this.insn = insn; - } - - @Override - boolean isField() { - return false; - } - - @Override - int getOpcode() { - return this.insn.getOpcode(); - } - - @Override - String getOwner() { - return this.insn.owner; - } - - @Override - void setOwner(String owner) { - this.insn.owner = owner; - } - - @Override - String getName() { - return this.insn.name; - } - - @Override - String getDesc() { - return this.insn.desc; - } - - @Override - void setDesc(String desc) { - this.insn.desc = desc; - } - } - - /** - * A static reference to a field backed by field get/put instruction - */ - private final class StaticFieldRef extends MemberRef { - - private final FieldInsnNode insn; - - private StaticFieldRef(FieldInsnNode insn) { - this.insn = insn; - } - - @Override - boolean isField() { - return true; - } - - @Override - int getOpcode() { - return this.insn.getOpcode(); - } - - @Override - String getOwner() { - return this.insn.owner; - } - - @Override - void setOwner(String owner) { - this.insn.owner = owner; - } - - @Override - String getName() { - return this.insn.name; - } - - @Override - String getDesc() { - return this.insn.desc; - } - - @Override - void setDesc(String desc) { - this.insn.desc = desc; - } - } - - /** - * A reference to a field or method backed by a method handle - */ - private final class HandleRef extends MemberRef { - - private Handle handle; - - private HandleRef(Handle handle) { - this.handle = handle; - } - - @Override - boolean isField() { - switch (this.handle.getTag()) { - case Opcodes.H_INVOKEVIRTUAL: - case Opcodes.H_INVOKESTATIC: - case Opcodes.H_INVOKEINTERFACE: - case Opcodes.H_INVOKESPECIAL: - case Opcodes.H_NEWINVOKESPECIAL: - return false; - case Opcodes.H_GETFIELD: - case Opcodes.H_GETSTATIC: - case Opcodes.H_PUTFIELD: - case Opcodes.H_PUTSTATIC: - return true; - default: - throw new MixinTransformerError("Invalid tag " + this.handle.getTag() + " for method handle " + this.handle + "."); - } - } - - @Override - int getOpcode() { - switch (this.handle.getTag()) { - case Opcodes.H_INVOKEVIRTUAL: - return Opcodes.INVOKEVIRTUAL; - case Opcodes.H_INVOKESTATIC: - return Opcodes.INVOKESTATIC; - case Opcodes.H_INVOKEINTERFACE: - return Opcodes.INVOKEINTERFACE; - case Opcodes.H_INVOKESPECIAL: - case Opcodes.H_NEWINVOKESPECIAL: - return Opcodes.INVOKESPECIAL; - case Opcodes.H_GETFIELD: - return Opcodes.GETFIELD; - case Opcodes.H_GETSTATIC: - return Opcodes.GETSTATIC; - case Opcodes.H_PUTFIELD: - return Opcodes.PUTFIELD; - case Opcodes.H_PUTSTATIC: - return Opcodes.PUTSTATIC; - default: - throw new MixinTransformerError("Invalid tag " + this.handle.getTag() + " for method handle " + this.handle + "."); - } - } - - @Override - String getOwner() { - return this.handle.getOwner(); - } - - @Override - void setOwner(String owner) { - this.handle = new Handle(this.handle.getTag(), owner, this.handle.getName(), this.handle.getDesc()); - } - - @Override - String getName() { - return this.handle.getName(); - } - - @Override - String getDesc() { - return this.handle.getDesc(); - } - - @Override - void setDesc(String desc) { - this.handle = new Handle(this.handle.getTag(), this.handle.getOwner(), this.handle.getName(), desc); - } + return memberRef.getMethodHandle(); } /** @@ -626,7 +441,7 @@ public class MixinTargetContext implements IReferenceMapperContext { MethodInsnNode methodNode = (MethodInsnNode)insn; if (methodNode.owner.equals(this.getClassRef()) && methodNode.name.equals(method.name) && methodNode.desc.equals(method.desc)) { methodNode.setOpcode(Opcodes.INVOKESPECIAL); - this.updateStaticBinding(method, new StaticMethodRef(methodNode)); + this.updateStaticBinding(method, new MemberRef.StaticMethodRef(methodNode)); return; } } @@ -666,13 +481,12 @@ public class MixinTargetContext implements IReferenceMapperContext { traversal); if (superMethod != null) { if (superMethod.getOwner().isMixin()) { - throw new InvalidMixinException(this, "Invalid " + ASMHelper.getOpcodeName(methodRef.getOpcode()) + " in " + this + " resolved " - + methodRef.getOwner() + " -> " + superMethod.getOwner() + " for " + methodRef.getName() + methodRef.getDesc()); + throw new InvalidMixinException(this, "Invalid " + methodRef + " in " + this + " resolved " + superMethod.getOwner() + + " but is mixin."); } methodRef.setOwner(superMethod.getOwner().getName()); } else if (ClassInfo.forName(methodRef.getOwner()).isMixin()) { - throw new MixinTransformerError("Error resolving " + ASMHelper.getOpcodeName(methodRef.getOpcode()) + " target for " - + methodRef.getOwner() + "." + methodRef.getName() + " in " + this); + throw new MixinTransformerError("Error resolving " + methodRef + " in " + this); } } @@ -732,9 +546,8 @@ public class MixinTargetContext implements IReferenceMapperContext { private String transformDescriptor(Type type) { if (type.getSort() == Type.METHOD) { return this.transformMethodDescriptor(type.getDescriptor()); - } else { - return this.transformSingleDescriptor(type); } + return this.transformSingleDescriptor(type); } private String transformSingleDescriptor(Type type) { @@ -907,7 +720,7 @@ public class MixinTargetContext implements IReferenceMapperContext { } /** - * Called immediately after the mixin is applied to targetClass + * Called imm imediately after the mixin is applied to targetClass * * @param transformedName Target class's transformed name * @param targetClass Target class diff --git a/src/main/java/org/spongepowered/asm/util/Constants.java b/src/main/java/org/spongepowered/asm/util/Constants.java index ce791d4b..f720f090 100644 --- a/src/main/java/org/spongepowered/asm/util/Constants.java +++ b/src/main/java/org/spongepowered/asm/util/Constants.java @@ -32,6 +32,7 @@ import org.spongepowered.asm.mixin.Mixin; */ public abstract class Constants { + public static final int JAVA8_CLASSFILE_VERSION = 52; public static final String INIT = ""; public static final String CLINIT = ""; public static final String IMAGINARY_SUPER = "super$";