966 lines
39 KiB
Java
966 lines
39 KiB
Java
package dev.w1zzrd.asm;
|
|
|
|
import dev.w1zzrd.asm.analysis.AsmAnnotation;
|
|
import dev.w1zzrd.asm.exception.MethodNodeResolutionException;
|
|
import dev.w1zzrd.asm.exception.SignatureCheckException;
|
|
import dev.w1zzrd.asm.exception.SignatureInstanceMismatchException;
|
|
import dev.w1zzrd.asm.signature.MethodSignature;
|
|
import dev.w1zzrd.asm.signature.TypeSignature;
|
|
import jdk.internal.org.objectweb.asm.ClassWriter;
|
|
import jdk.internal.org.objectweb.asm.Handle;
|
|
import jdk.internal.org.objectweb.asm.Opcodes;
|
|
import jdk.internal.org.objectweb.asm.Type;
|
|
import jdk.internal.org.objectweb.asm.tree.*;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
import static jdk.internal.org.objectweb.asm.ClassWriter.COMPUTE_MAXS;
|
|
|
|
public class Combine {
|
|
private final ArrayList<DynamicSourceUnit> graftSources = new ArrayList<>();
|
|
|
|
private final ClassNode target;
|
|
|
|
|
|
public Combine(ClassNode target) {
|
|
this.target = target;
|
|
}
|
|
|
|
public void inject(MethodNode node, GraftSource source) {
|
|
final AsmAnnotation<Inject> annotation = source.getMethodInjectAnnotation(node);
|
|
|
|
switch ((InPlaceInjection)annotation.getEnumEntry("value")) {
|
|
case INSERT: // Explicitly insert a *new* method
|
|
insert(node, source);
|
|
break;
|
|
case REPLACE: // Explicitly replace an *existing* method
|
|
replace(node, source, true);
|
|
break;
|
|
case INJECT: // Insert method by either replacing an existing method or inserting a new method
|
|
if (initiateGrafting(node, source))
|
|
return;
|
|
|
|
insertOrReplace(node, source);
|
|
|
|
finishGrafting(node, source);
|
|
break;
|
|
case AFTER: // Inject a method's instructions after the original instructions in a given method
|
|
append(node, source);
|
|
break;
|
|
case BEFORE: // Inject a method's instructions before the original instructions in a given method
|
|
prepend(node, source);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extend implementation of a method past its regular return. This grafts the given method node to the end of the
|
|
* targeted method node, such that, instead of returning, the code in the given method node is executed with the
|
|
* return value from the original node as the "argument" to the grafted node.
|
|
* @param extension Node to extend method with
|
|
* @param source The {@link GraftSource} from which the method node will be adapted
|
|
*/
|
|
public void append(MethodNode extension, GraftSource source) {
|
|
if (initiateGrafting(extension, source))
|
|
return;
|
|
|
|
final MethodResolution resolution = resolveMethod(extension, source, true);
|
|
boolean acceptReturn = resolution.acceptReturn;
|
|
adaptMethod(extension, source);
|
|
|
|
// Get the method signatures so we know what we're working with local-variable-wise ;)
|
|
final MethodSignature msig = new MethodSignature(resolution.node.desc);
|
|
final MethodSignature xsig = new MethodSignature(extension.desc);
|
|
|
|
// Get total argument count, including implicit "this" argument
|
|
final int graftArgCount = xsig.getArgCount() + (isStatic(extension) ? 0 : 1);
|
|
final int targetArgCount = msig.getArgCount() + (isStatic(resolution.node) ? 0 : 1);
|
|
|
|
// If graft method cares about the return value of the original method, i.e. accepts it as an extra "argument"
|
|
if (acceptReturn && !msig.getRet().isVoidType()) {
|
|
//noinspection OptionalGetWithoutIsPresent
|
|
LocalVariableNode retVar = extension.localVariables
|
|
.stream()
|
|
.filter(it -> it.index == graftArgCount - 1)
|
|
.findFirst()
|
|
.get();
|
|
|
|
// Inject return variable
|
|
adjustArgument(resolution.node, retVar, true, true);
|
|
|
|
// Handle retvar specially
|
|
extension.localVariables.remove(retVar);
|
|
|
|
// Make space in the original frames for the return var
|
|
// This isn't an optimal solution, but it works for now
|
|
adjustFramesForRetVar(resolution.node.instructions, targetArgCount);
|
|
|
|
// Replace return instructions with GOTOs to the last instruction in the list
|
|
// Return values are stored in retVar
|
|
storeAndGotoFromReturn(resolution.node, resolution.node.instructions, retVar.index, xsig);
|
|
} else {
|
|
// If we don't care about the return value from the original, we can replace returns with pops
|
|
popAndGotoFromReturn(resolution.node, resolution.node.instructions, xsig);
|
|
}
|
|
|
|
List<LocalVariableNode> extVars = getVarsOver(extension.localVariables, xsig.getArgCount());
|
|
|
|
// Add extension vars to target
|
|
resolution.node.localVariables.addAll(extVars);
|
|
|
|
// Add extension instructions to instruction list
|
|
resolution.node.instructions.add(extension.instructions);
|
|
|
|
// Make sure we extend the scope of the original method arguments
|
|
for (int i = 0; i < targetArgCount; ++i)
|
|
adjustArgument(resolution.node, getVarAt(resolution.node.localVariables, i), false, false);
|
|
|
|
// Recompute maximum variable count
|
|
resolution.node.maxLocals = Math.max(
|
|
Math.max(
|
|
targetArgCount + 1,
|
|
graftArgCount + 1
|
|
),
|
|
resolution.node.localVariables
|
|
.stream()
|
|
.map(it -> it.index)
|
|
.max(Comparator.comparingInt(a -> a)).orElse(0) + 1
|
|
);
|
|
|
|
// Recompute maximum stack size
|
|
resolution.node.maxStack = Math.max(resolution.node.maxStack, extension.maxStack);
|
|
|
|
finishGrafting(extension, source);
|
|
}
|
|
|
|
public void prepend(MethodNode extension, GraftSource source) {
|
|
if (initiateGrafting(extension, source))
|
|
return;
|
|
|
|
final MethodNode target = resolveMethod(extension, source, false).node;
|
|
adaptMethod(extension, source);
|
|
|
|
MethodSignature sig = new MethodSignature(extension.desc);
|
|
|
|
target.localVariables.addAll(getVarsOver(extension.localVariables, sig.getArgCount()));
|
|
extension.instructions.add(target.instructions);
|
|
|
|
target.instructions = extension.instructions;
|
|
|
|
// Extend argument scope to cover prepended code
|
|
for (int i = 0; i < sig.getArgCount(); ++i)
|
|
adjustArgument(target, getVarAt(target.localVariables, i), true, false);
|
|
|
|
finishGrafting(extension, source);
|
|
}
|
|
|
|
public void replace(MethodNode inject, GraftSource source, boolean preserveOriginalAccess) {
|
|
if (initiateGrafting(inject, source))
|
|
return;
|
|
|
|
final MethodNode remove = checkMethodExists(source.getMethodTargetName(inject), source.getMethodTargetSignature(inject, false));
|
|
ensureMatchingSignatures(remove, inject, Opcodes.ACC_STATIC);
|
|
if (preserveOriginalAccess)
|
|
copySignatures(remove, inject, Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED | Opcodes.ACC_PRIVATE);
|
|
|
|
insertOrReplace(inject, source);
|
|
|
|
finishGrafting(inject, source);
|
|
}
|
|
|
|
public void insert(MethodNode inject, GraftSource source) {
|
|
if (initiateGrafting(inject, source))
|
|
return;
|
|
|
|
checkMethodNotExists(source.getMethodTargetName(inject), source.getMethodTargetSignature(inject, false));
|
|
insertOrReplace(inject, source);
|
|
|
|
finishGrafting(inject, source);
|
|
}
|
|
|
|
protected void insertOrReplace(MethodNode inject, GraftSource source) {
|
|
MethodNode replace = findMethodNode(source.getMethodTargetName(inject), source.getMethodTargetSignature(inject, false));
|
|
|
|
if (replace != null)
|
|
this.target.methods.remove(replace);
|
|
|
|
adaptMethod(inject, source);
|
|
|
|
this.target.methods.add(inject);
|
|
}
|
|
|
|
public void inject(FieldNode field, GraftSource source) {
|
|
if (field.desc.equals(source.getTypeName()))
|
|
field.desc = target.name;
|
|
|
|
// Remove existing field with same name
|
|
for (FieldNode node : target.fields)
|
|
if (node.name.equals(field.name)) {
|
|
target.fields.remove(node);
|
|
break;
|
|
}
|
|
|
|
target.fields.add(field);
|
|
}
|
|
|
|
public void setSuperClass(String superDesc) {
|
|
// Theoretically usable for redefining Object (under a new ClassLoader)
|
|
if (superDesc == null) {
|
|
target.superName = null;
|
|
return;
|
|
}
|
|
|
|
if (new TypeSignature(superDesc).isPrimitive())
|
|
throw new SignatureCheckException("Superclass cannot be primitive: "+superDesc);
|
|
|
|
target.superName = superDesc;
|
|
}
|
|
|
|
public String getSuperclass() {
|
|
return target.superName;
|
|
}
|
|
|
|
public TypeSignature[] getInterfaces() {
|
|
return target.interfaces.stream().map(TypeSignature::new).toArray(TypeSignature[]::new);
|
|
}
|
|
|
|
public boolean removeInterface(String interfaceDesc) {
|
|
return target.interfaces.remove(interfaceDesc);
|
|
}
|
|
|
|
public void addInterface(String interfaceDesc) {
|
|
if (!target.interfaces.contains(interfaceDesc))
|
|
target.interfaces.add(interfaceDesc);
|
|
}
|
|
|
|
|
|
private boolean initiateGrafting(MethodNode node, GraftSource source) {
|
|
DynamicSourceUnit unit = new DynamicSourceUnit(source, node);
|
|
boolean alreadyGrafting = graftSources.contains(unit);
|
|
|
|
if (!alreadyGrafting)
|
|
graftSources.add(unit);
|
|
|
|
return alreadyGrafting;
|
|
}
|
|
|
|
private void finishGrafting(MethodNode node, GraftSource source) {
|
|
if (!graftSources.remove(new DynamicSourceUnit(source, node)))
|
|
throw new IllegalStateException("Attempt to finish grafting when grafting is not it progress!");
|
|
}
|
|
|
|
|
|
/**
|
|
* Compile target class data to a byte array
|
|
* @return Class data
|
|
*/
|
|
public byte[] toByteArray() {
|
|
return toByteArray(COMPUTE_MAXS);
|
|
}
|
|
|
|
/**
|
|
* Compile target class data to a byte array
|
|
* @param writerFlags Flags to pass to the {@link ClassWriter} used to compile the target class
|
|
* @return Class data
|
|
*/
|
|
public byte[] toByteArray(int writerFlags) {
|
|
ClassWriter writer = new ClassWriter(writerFlags);
|
|
//target.methods.forEach(method -> method.localVariables.forEach(var -> var.name = var.name.replace(" ", "")));
|
|
target.accept(writer);
|
|
|
|
return writer.toByteArray();
|
|
}
|
|
|
|
/**
|
|
* Compile target class data to byte array and load with system class loader
|
|
* @return Class loaded by the loader
|
|
*/
|
|
public Class<?> compile() {
|
|
return compile(ClassLoader.getSystemClassLoader());
|
|
}
|
|
|
|
/**
|
|
* Compile target class data to byte array and load with the given class loader
|
|
* @param loader Loader to use when loading the class
|
|
* @return Class loaded by the loader
|
|
*/
|
|
public Class<?> compile(ClassLoader loader) {
|
|
Method m = null;
|
|
try {
|
|
m = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
|
|
} catch (NoSuchMethodException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
assert m != null;
|
|
m.setAccessible(true);
|
|
//ReflectCompat.setAccessible(m, true);
|
|
|
|
byte[] data = toByteArray();
|
|
|
|
try {
|
|
return (Class<?>) m.invoke(loader, data, 0, data.length);
|
|
} catch (IllegalAccessException | InvocationTargetException e) {
|
|
e.printStackTrace();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getTargetName() {
|
|
return target.name;
|
|
}
|
|
|
|
public ClassNode getClassNode() {
|
|
return target;
|
|
}
|
|
|
|
/**
|
|
* Prepares a {@link MethodNode} for grafting on to a given method and into the targeted {@link ClassNode}
|
|
* @param node Node to adapt
|
|
* @param source The {@link GraftSource} from which the node will be adapted
|
|
*/
|
|
protected void adaptMethod(MethodNode node, GraftSource source) {
|
|
// Adapt instructions
|
|
for (AbstractInsnNode insn = node.instructions.getFirst(); insn != null; insn = insn.getNext()) {
|
|
if (insn instanceof MethodInsnNode) insn = adaptMethodInsn((MethodInsnNode) insn, source, node);
|
|
else if (insn instanceof LdcInsnNode) adaptLdcInsn((LdcInsnNode) insn, source.getTypeName());
|
|
else if (insn instanceof FrameNode) adaptFrameNode((FrameNode) insn, source);
|
|
else if (insn instanceof FieldInsnNode) adaptFieldInsn((FieldInsnNode) insn, source);
|
|
else if (insn instanceof InvokeDynamicInsnNode) adaptInvokeDynamicInsn((InvokeDynamicInsnNode) insn, source);
|
|
}
|
|
|
|
// Adapt variable types
|
|
final String graftTypeName = "L"+source.getTypeName()+";";
|
|
for (LocalVariableNode varNode : node.localVariables)
|
|
if (graftTypeName.equals(varNode.desc))
|
|
varNode.desc = graftTypeName;
|
|
|
|
node.name = source.getMethodTargetName(node);
|
|
}
|
|
|
|
protected static LabelNode findOrMakeEndLabel(InsnList nodes) {
|
|
AbstractInsnNode last = nodes.getLast();
|
|
|
|
while (last instanceof FrameNode) last = last.getPrevious();
|
|
|
|
if (last instanceof LabelNode)
|
|
return (LabelNode) last;
|
|
|
|
LabelNode label = new LabelNode();
|
|
|
|
nodes.add(label);
|
|
return label;
|
|
}
|
|
|
|
protected static boolean hasEndJumpFrame(InsnList nodes) {
|
|
return nodes.getLast() instanceof FrameNode && nodes.getLast().getPrevious() instanceof LabelNode;
|
|
}
|
|
|
|
protected LabelNode makeEndJumpFrame(InsnList nodes, MethodSignature sig, MethodNode source) {
|
|
LabelNode endLabel = findOrMakeEndLabel(nodes);
|
|
|
|
List<Object> local = makeFrameLocals(sig.getArgs());
|
|
if (!isStatic(source))
|
|
local.add(0, target.name);
|
|
|
|
//nodes.add(frameInsert + 1, new FrameNode(Opcodes.F_SAME, 0, null, 0, null));
|
|
nodes.insert(endLabel, new FrameNode(Opcodes.F_FULL, local.size(), local.toArray(), 0, new Object[0]));
|
|
|
|
return endLabel;
|
|
}
|
|
|
|
private void storeAndGotoFromReturn(MethodNode source, InsnList nodes, int storeIndex, MethodSignature sig) {
|
|
// If we already have a final frame, there's no need to add one
|
|
LabelNode endLabel = hasEndJumpFrame(nodes) ? findOrMakeEndLabel(nodes) : makeEndJumpFrame(nodes, sig, source);
|
|
|
|
INSTRUCTION_LOOP:
|
|
for (AbstractInsnNode current = nodes.getFirst(); current != null; current = current.getNext()) {
|
|
switch (current.getOpcode()) {
|
|
case Opcodes.IRETURN:
|
|
nodes.set(current, current = new IntInsnNode(Opcodes.ISTORE, storeIndex));
|
|
break;
|
|
|
|
case Opcodes.FRETURN:
|
|
nodes.set(current, current = new IntInsnNode(Opcodes.FSTORE, storeIndex));
|
|
break;
|
|
|
|
case Opcodes.ARETURN:
|
|
nodes.set(current, current = new IntInsnNode(Opcodes.ASTORE, storeIndex));
|
|
break;
|
|
|
|
case Opcodes.LRETURN:
|
|
nodes.set(current, current = new IntInsnNode(Opcodes.LSTORE, storeIndex));
|
|
break;
|
|
|
|
case Opcodes.DRETURN:
|
|
nodes.set(current, current = new IntInsnNode(Opcodes.DSTORE, storeIndex));
|
|
break;
|
|
|
|
case Opcodes.RETURN:
|
|
nodes.set(current, current = new JumpInsnNode(Opcodes.GOTO, endLabel));
|
|
// Fallthrough
|
|
|
|
default:
|
|
continue INSTRUCTION_LOOP;
|
|
}
|
|
nodes.insert(current, current = new JumpInsnNode(Opcodes.GOTO, endLabel));
|
|
}
|
|
}
|
|
|
|
private void popAndGotoFromReturn(MethodNode source, InsnList nodes, MethodSignature sig) {
|
|
// If we already have a final frame, there's no need to add one
|
|
LabelNode endLabel = hasEndJumpFrame(nodes) ? findOrMakeEndLabel(nodes) : makeEndJumpFrame(nodes, sig, source);
|
|
|
|
INSTRUCTION_LOOP:
|
|
for (AbstractInsnNode current = nodes.getFirst(); current != null; current = current.getNext()) {
|
|
switch (current.getOpcode()) {
|
|
case Opcodes.IRETURN:
|
|
case Opcodes.FRETURN:
|
|
case Opcodes.ARETURN:
|
|
nodes.set(current, current = new InsnNode(Opcodes.POP));
|
|
break;
|
|
|
|
case Opcodes.LRETURN:
|
|
case Opcodes.DRETURN:
|
|
nodes.set(current, current = new InsnNode(Opcodes.POP2));
|
|
break;
|
|
|
|
case Opcodes.RETURN:
|
|
nodes.set(current, current = new JumpInsnNode(Opcodes.GOTO, endLabel));
|
|
// Fallthrough
|
|
|
|
default:
|
|
continue INSTRUCTION_LOOP;
|
|
}
|
|
|
|
nodes.insert(current, current = new JumpInsnNode(Opcodes.GOTO, endLabel));
|
|
}
|
|
}
|
|
|
|
private static void adjustArgument(MethodNode node, LocalVariableNode varNode, boolean backward, boolean insert) {
|
|
if (backward) {
|
|
// Finds first label or creates it
|
|
LabelNode firstLabel = findLabelBeforeReturn(node.instructions.getFirst(), AbstractInsnNode::getNext);
|
|
|
|
// No label found before a return: create one
|
|
if (firstLabel == null)
|
|
node.instructions.insert(firstLabel = new LabelNode());
|
|
|
|
varNode.start = firstLabel;
|
|
} else {
|
|
// Finds last label or creates it
|
|
LabelNode lastLabel = findLabelBeforeReturn(node.instructions.getLast(), AbstractInsnNode::getPrevious);
|
|
|
|
// No label found after a return: create one
|
|
if (lastLabel == null)
|
|
node.instructions.add(lastLabel = new LabelNode());
|
|
|
|
varNode.end = lastLabel;
|
|
}
|
|
|
|
if (insert) {
|
|
// Increment existing variable indices by 1
|
|
for (LocalVariableNode vNode : node.localVariables)
|
|
if (vNode.index >= varNode.index)
|
|
++vNode.index;
|
|
|
|
// Update instructions referencing local variables
|
|
for (AbstractInsnNode insn = node.instructions.getFirst(); insn != null; insn = insn.getNext()) {
|
|
if (insn instanceof VarInsnNode && ((VarInsnNode) insn).var >= varNode.index)
|
|
++((VarInsnNode) insn).var;
|
|
}
|
|
|
|
// Add variable to locals
|
|
node.localVariables.add(varNode);
|
|
}
|
|
}
|
|
|
|
protected static void adjustFramesForRetVar(InsnList nodes, int argc) {
|
|
boolean isFirst = true;
|
|
for (AbstractInsnNode node = nodes.getFirst(); node != null; node = node.getNext())
|
|
if (node instanceof FrameNode) {
|
|
if (isFirst) {
|
|
isFirst = false;
|
|
|
|
if (((FrameNode) node).type == Opcodes.F_APPEND) {
|
|
List<Object> append = new ArrayList<>(((FrameNode) node).local);
|
|
append.add(0, Opcodes.TOP);
|
|
((FrameNode) node).local = append;
|
|
}
|
|
}
|
|
|
|
if (((FrameNode) node).type == Opcodes.F_FULL) {
|
|
List<Object> append = new ArrayList<>(((FrameNode) node).local);
|
|
append.add(argc, Opcodes.TOP);
|
|
((FrameNode) node).local = append;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Adapts a grafted method instruction node to fit its surrogate
|
|
* @param node Grafted method instruction node
|
|
* @param source The {@link GraftSource} from which the instruction node will be adapted
|
|
*/
|
|
protected AbstractInsnNode adaptMethodInsn(MethodInsnNode node, GraftSource source, MethodNode sourceMethod) {
|
|
if (node.owner.equals(source.getTypeName())) {
|
|
//final MethodNode injected = source.getInjectedMethod(node.name, node.desc);
|
|
//if (injected != null) {
|
|
node.owner = this.target.name;
|
|
//node.name = source.getMethodTargetName(injected);
|
|
//node.desc = adaptMethodSignature(node.desc, source);
|
|
//}
|
|
return node;
|
|
} else if (node.owner.equals("dev/w1zzrd/asm/Directives")) { // ASM target directives
|
|
if (node.name.equals(Directives.directiveNameByTarget(DirectiveTarget.TargetType.CALL_SUPER))) {
|
|
// We're attempting to redirect a call to a superclass
|
|
for (AbstractInsnNode prev = node.getPrevious(); prev != null; prev = prev.getPrevious()) {
|
|
|
|
if (prev instanceof MethodInsnNode &&
|
|
(((MethodInsnNode) prev).owner.equals(target.name) ||
|
|
((MethodInsnNode) prev).owner.equals(source.getTypeName()))) {
|
|
// Point method owner to superclass
|
|
((MethodInsnNode) prev).owner = target.superName;
|
|
|
|
// Since we're calling super, we want to make it a special call
|
|
if (prev.getOpcode() == Opcodes.INVOKEVIRTUAL)
|
|
((MethodInsnNode) prev).setOpcode(Opcodes.INVOKESPECIAL);
|
|
} else if (prev instanceof FieldInsnNode &&
|
|
(((FieldInsnNode) prev).owner.equals(target.name) ||
|
|
((FieldInsnNode) prev).owner.equals(source.getTypeName()))) {
|
|
// Just change the field we're accessing to the targets superclass' field
|
|
((FieldInsnNode) prev).owner = target.superName;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
sourceMethod.instructions.remove(node);
|
|
|
|
return prev;
|
|
}
|
|
|
|
throw new RuntimeException(String.format("Could not locate a target for directive %s", node.name));
|
|
} else if (node.name.equals(Directives.directiveNameByTarget(DirectiveTarget.TargetType.CALL_ORIGINAL))) {
|
|
// We want to redirect execution to the original method code
|
|
// The callOriginal method returns void, so the stack should be empty at this point
|
|
|
|
InsnList insnList = sourceMethod.instructions;
|
|
|
|
// If we already have a final frame, there's no need to add one
|
|
LabelNode endLabel = hasEndJumpFrame(insnList) ?
|
|
findOrMakeEndLabel(insnList) :
|
|
makeEndJumpFrame(insnList, new MethodSignature(sourceMethod.desc), sourceMethod);
|
|
|
|
AbstractInsnNode jumpInsn = new JumpInsnNode(Opcodes.GOTO, endLabel);
|
|
insnList.set(node, jumpInsn);
|
|
|
|
MethodSignature sig = new MethodSignature(sourceMethod.desc);
|
|
final Class<?>[] ignoredNodes = {LineNumberNode.class, LabelNode.class, FrameNode.class};
|
|
AbstractInsnNode afterJump = getNextNode(jumpInsn, ignoredNodes);
|
|
|
|
if (!sig.getRet().isVoidType()) {
|
|
// Now we want to remove extraneous (unreachable) return instructions
|
|
afterJump = getNextNode(afterJump, ignoredNodes);
|
|
|
|
// This should remove extraneous return instructions, along with any constants pushed to the stack
|
|
if (afterJump.getOpcode() >= Opcodes.IRETURN && afterJump.getOpcode() < Opcodes.RETURN) {
|
|
insnList.remove(afterJump);
|
|
insnList.remove(getNextNode(jumpInsn, ignoredNodes));
|
|
}
|
|
} else if (afterJump.getOpcode() == Opcodes.RETURN) {
|
|
// This should just remove the extraneous RETURN instruction
|
|
insnList.remove(afterJump);
|
|
}
|
|
|
|
return jumpInsn;
|
|
}
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
/**
|
|
* Adapts a grafted constant instruction node to fit its surrogate
|
|
* @param node Grafted LDC instruction node
|
|
* @param originalOwner Fully-qualified name of the original owner class
|
|
*/
|
|
protected void adaptLdcInsn(LdcInsnNode node, String originalOwner) {
|
|
if (node.cst instanceof Type && ((Type) node.cst).getInternalName().equals(originalOwner))
|
|
node.cst = Type.getType(String.format("L%s;", originalOwner));
|
|
}
|
|
|
|
protected void adaptFrameNode(FrameNode node, GraftSource source) {
|
|
adaptFrameTypes(node.stack, source);
|
|
adaptFrameTypes(node.local, source);
|
|
}
|
|
|
|
|
|
protected void adaptFrameTypes(List<Object> types, GraftSource source) {
|
|
if (types == null)
|
|
return;
|
|
|
|
final String sourceTypeName = "L"+source.getTypeName()+";";
|
|
final String targetTypeName = "L"+target.name+";";
|
|
|
|
for (int i = 0; i < types.size(); ++i) {
|
|
if (types.get(i) instanceof Type) {
|
|
Type t = (Type) types.get(i);
|
|
|
|
if (t.getSort() == Type.OBJECT && sourceTypeName.equals(t.getInternalName()))
|
|
types.set(i, Type.getType(targetTypeName));
|
|
else if (t.getSort() == Type.METHOD)
|
|
types.set(i, Type.getMethodType(adaptMethodSignature(t.getDescriptor(), source)));
|
|
} else if (types.get(i) instanceof String && source.getTypeName().equals(types.get(i)))
|
|
types.set(i, target.name);
|
|
}
|
|
}
|
|
|
|
protected static List<Object> makeFrameLocals(TypeSignature... sigs) {
|
|
ArrayList<Object> local = new ArrayList<>();
|
|
|
|
for (TypeSignature sig : sigs)
|
|
if (sig.isPrimitive())
|
|
switch (sig.getSig().charAt(0)) {
|
|
case 'B':
|
|
case 'Z':
|
|
case 'C':
|
|
case 'I':
|
|
local.add(Opcodes.INTEGER);
|
|
break;
|
|
|
|
case 'F':
|
|
local.add(Opcodes.FLOAT);
|
|
break;
|
|
|
|
case 'J':
|
|
if (sig.isTop())
|
|
local.add(Opcodes.TOP);
|
|
else
|
|
local.add(Opcodes.LONG);
|
|
break;
|
|
|
|
case 'D':
|
|
if (sig.isTop())
|
|
local.add(Opcodes.TOP);
|
|
else
|
|
local.add(Opcodes.DOUBLE);
|
|
break;
|
|
}
|
|
else if (sig.isNull()) local.add(Opcodes.NULL);
|
|
else if (sig.isUninitialized()) local.add(Opcodes.UNINITIALIZED_THIS);
|
|
else if (sig.isArray()) local.add(sig.getSig());
|
|
else local.add(sig.getSig().substring(1, sig.getSig().length() - 1));
|
|
|
|
return local;
|
|
}
|
|
|
|
protected void adaptFieldInsn(FieldInsnNode node, GraftSource source) {
|
|
if (node.owner.equals(source.getTypeName()))
|
|
node.owner = target.name;
|
|
}
|
|
|
|
protected void adaptInvokeDynamicInsn(InvokeDynamicInsnNode insn, GraftSource source) {
|
|
if (insn.bsmArgs[1] instanceof Handle && ((Handle) insn.bsmArgs[1]).getOwner().equals(source.getTypeName())) {
|
|
// We have an INVOKEDYNAMIC to a method in the graft source class
|
|
// The target has to be injected into the target
|
|
Handle handle = (Handle) insn.bsmArgs[1];
|
|
|
|
for (MethodNode mNode : target.methods)
|
|
if (mNode.name.equals(handle.getName()) && mNode.desc.equals(handle.getDesc()))
|
|
return; // The target has already been injected
|
|
|
|
MethodNode inject = source.getMethodNode(handle.getName(), handle.getDesc());
|
|
if (inject == null)
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Could not locate lambda target %s%s in graft source %s",
|
|
handle.getName(),
|
|
handle.getDesc(),
|
|
source.getTypeName()
|
|
));
|
|
|
|
// Attempt to inject lambda target site into target class
|
|
insert(inject, source);
|
|
|
|
// The INVOKEDYNAMIC now points to a call site in the target class
|
|
insn.bsmArgs[1] = new Handle(
|
|
handle.getTag(),
|
|
target.name,
|
|
handle.getName(),
|
|
adaptMethodSignature(handle.getDesc(), source)
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Replaces any references to the graft source type with the target type
|
|
* @param desc Method descriptor to adapt
|
|
* @param source {@link GraftSource} to replace references to
|
|
* @return Method signature with references to target type in place of graft source type
|
|
*/
|
|
protected String adaptMethodSignature(String desc, GraftSource source) {
|
|
TypeSignature graftSig = new TypeSignature("L"+source.getTypeName()+";");
|
|
MethodSignature sig = new MethodSignature(desc);
|
|
for (int i = 0; i < sig.getArgCount(); ++i)
|
|
if (sig.getArg(i).getArrayAtomType().equals(graftSig))
|
|
sig.setArg(
|
|
i,
|
|
new TypeSignature(
|
|
"L"+target.name+";",
|
|
sig.getArg(i).getArrayDepth(),
|
|
false
|
|
)
|
|
);
|
|
|
|
if (sig.getRet().getArrayAtomType().equals(graftSig))
|
|
sig.setRet(new TypeSignature(
|
|
"L"+target.name+";",
|
|
sig.getRet().getArrayDepth(),
|
|
false
|
|
));
|
|
|
|
return sig.toString();
|
|
}
|
|
|
|
/**
|
|
* Ensure that a method node matching the given description does not exist in the targeted class
|
|
* @param name Name of the method node
|
|
* @param descriptor Descriptor of the method node
|
|
* @throws MethodNodeResolutionException If a method matching the given description could be found
|
|
*/
|
|
protected final void checkMethodNotExists(String name, MethodSignature descriptor) {
|
|
final MethodNode target = findMethodNode(name, descriptor);
|
|
|
|
if (target != null)
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Cannot insert method node \"%s%s\" into class: node with name and signature already exists",
|
|
name,
|
|
descriptor
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Ensure that a method node matching the given description exists in the targeted class
|
|
* @param name Name of the method node
|
|
* @param descriptor Descriptor of the method node
|
|
* @return The located method node
|
|
* @throws MethodNodeResolutionException If no method node matching the given description could be found
|
|
*/
|
|
protected final @NotNull MethodNode checkMethodExists(String name, MethodSignature descriptor) {
|
|
final MethodNode target = findMethodNode(name, descriptor);
|
|
|
|
if (target == null)
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Cannot replace method node \"%s\" in class: node with name and signature does not exist",
|
|
name
|
|
));
|
|
|
|
return target;
|
|
}
|
|
|
|
/**
|
|
* Find a method node in the targeted class by name and descriptor
|
|
* @param name Name of the method node to find
|
|
* @param desc Descriptor of the method node to find
|
|
* @return A matching {@link MethodNode} if one exists, else null
|
|
*/
|
|
protected @Nullable MethodNode findMethodNode(String name, MethodSignature desc) {
|
|
return target.methods
|
|
.stream()
|
|
.filter(it -> it.name.equals(name) && new MethodSignature(it.desc).equals(desc))
|
|
.findFirst()
|
|
.orElse(null);
|
|
}
|
|
|
|
/**
|
|
* Ensure that the injection method has matching access flags as the targeted method
|
|
* @param target Targeted method
|
|
* @param inject Injected method
|
|
* @param flags Flags to check equality of (see {@link Opcodes})
|
|
*/
|
|
protected static void ensureMatchingSignatures(MethodNode target, MethodNode inject, int flags) {
|
|
if ((target.access & flags) != (inject.access & flags))
|
|
throw new SignatureInstanceMismatchException(String.format(
|
|
"Access flag mismatch for target method %s (with flags %d) and inject method %s (with flags %d)",
|
|
target.name,
|
|
target.access & flags,
|
|
inject.name,
|
|
inject.access & flags
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Copy access flags from the targeted method to the injected method
|
|
* @param target Targeted method
|
|
* @param inject Injected method
|
|
* @param flags Flags to copy (see {@link Opcodes})
|
|
*/
|
|
protected static void copySignatures(MethodNode target, MethodNode inject, int flags) {
|
|
inject.access ^= (inject.access & flags) ^ (target.access & flags);
|
|
}
|
|
|
|
protected static AbstractInsnNode getNextNode(AbstractInsnNode node, Class<?>... skipTypes) {
|
|
return traverseNode(node, AbstractInsnNode::getNext, skipTypes);
|
|
}
|
|
|
|
protected static AbstractInsnNode getPreviousNode(AbstractInsnNode node, Class<?>... skipTypes) {
|
|
return traverseNode(node, AbstractInsnNode::getPrevious, skipTypes);
|
|
}
|
|
|
|
private static AbstractInsnNode traverseNode(AbstractInsnNode node, INodeTraversal traversal, Class<?>[] skipTypes) {
|
|
TRAVERSAL:
|
|
for (AbstractInsnNode trav = traversal.traverse(node); trav != null; trav = traversal.traverse(trav)) {
|
|
for (Class<?> cls : skipTypes)
|
|
if (trav.getClass().equals(cls))
|
|
continue TRAVERSAL;
|
|
return trav;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
|
|
@SuppressWarnings("unused") // Used for debugging
|
|
public static java.util.List<? extends AbstractInsnNode> dumpInsns(MethodNode node) {
|
|
return Arrays.asList(node.instructions.toArray());
|
|
}
|
|
|
|
protected static List<LocalVariableNode> getVarsOver(List<LocalVariableNode> varNodes, int minIndex) {
|
|
return varNodes.stream().filter(it -> it.index >= minIndex).collect(Collectors.toList());
|
|
}
|
|
|
|
protected static LocalVariableNode getVarAt(List<LocalVariableNode> varNodes, int index) {
|
|
return varNodes.stream().filter(it -> it.index == index).findFirst().orElse(null);
|
|
}
|
|
|
|
|
|
protected static @Nullable LabelNode findLabelBeforeReturn(AbstractInsnNode start, INodeTraversal traverse) {
|
|
for (AbstractInsnNode cur = start; cur != null; cur = traverse.traverse(cur))
|
|
if (cur instanceof LabelNode) // Traversal hit label
|
|
return (LabelNode) cur;
|
|
else if (cur.getOpcode() >= Opcodes.IRETURN && cur.getOpcode() <= Opcodes.RETURN) // Traversal hit return
|
|
return null;
|
|
|
|
return null; // Nothing was found
|
|
}
|
|
|
|
protected MethodResolution resolveMethod(MethodNode inject, GraftSource source, boolean allowAcceptRet) {
|
|
AsmAnnotation<Inject> annot = AsmAnnotation.getAnnotation(Inject.class, inject.visibleAnnotations);
|
|
if (!allowAcceptRet && (Boolean)annot.getEntry("acceptOriginalReturn"))
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Method %s marked as accepting original return, but injection strategy prohibits this!",
|
|
inject.name
|
|
));
|
|
|
|
boolean acceptRet = annot.getEntry("acceptOriginalReturn");
|
|
|
|
String sig = adaptMethodSignature(source.getMethodTarget(inject), source);
|
|
final MethodSignature mSig = new MethodSignature(sig);
|
|
|
|
final String targetName = source.getMethodTargetName(inject);
|
|
|
|
// Collect possible method candidates by name
|
|
List<MethodNode> candidates = this.target
|
|
.methods
|
|
.stream()
|
|
.filter(it -> it.name.equals(targetName))
|
|
.collect(Collectors.toList());
|
|
|
|
// No candidates match the base criteria
|
|
if (candidates.isEmpty())
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Cannot find and target candidates for method %s%s",
|
|
inject.name,
|
|
inject.desc
|
|
));
|
|
|
|
// If we accept original return value, target with not contain final argument
|
|
if (acceptRet) {
|
|
if (!mSig.getRet().equals(mSig.getArg(mSig.getArgCount() - 1)))
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Return value must match final method argument when accepting return: %s%s",
|
|
inject.name,
|
|
inject.desc
|
|
));
|
|
sig = mSig.withoutLastArg().toString();
|
|
}
|
|
|
|
final String findSig = sig;
|
|
final List<MethodNode> cand = candidates;
|
|
candidates = candidates.stream().filter(it -> it.desc.equals(findSig)).collect(Collectors.toList());
|
|
|
|
// We have no candidates
|
|
if (candidates.isEmpty()) {
|
|
// If no candidates were found for the explicitly declared signature,
|
|
// check if accepting original return value was implied
|
|
if (!acceptRet &&
|
|
allowAcceptRet &&
|
|
mSig.getArgCount() > 0 &&
|
|
mSig.getRet().equals(mSig.getArg(mSig.getArgCount() - 1))) {
|
|
// Search for method without the implied return value argument
|
|
final String fSig = mSig.withoutLastArg().toString();
|
|
candidates = cand.stream().filter(it -> it.desc.equals(fSig)).collect(Collectors.toList());
|
|
|
|
// Do we have a match?
|
|
if (candidates.size() == 1)
|
|
return new MethodResolution(candidates.get(0), true);
|
|
}
|
|
|
|
throw new MethodNodeResolutionException(String.format(
|
|
"Cannot find and target candidates for method %s%s",
|
|
inject.name,
|
|
inject.desc
|
|
));
|
|
}
|
|
|
|
// If we have a candidate, it will have a specific name and signature
|
|
// Therefore there cannot be more than one candidate by JVM convention
|
|
return new MethodResolution(candidates.get(0), acceptRet && allowAcceptRet);
|
|
}
|
|
|
|
protected static boolean isStatic(MethodNode node) {
|
|
return (node.access & Opcodes.ACC_STATIC) != 0;
|
|
}
|
|
|
|
protected interface INodeTraversal {
|
|
AbstractInsnNode traverse(AbstractInsnNode cur);
|
|
}
|
|
|
|
private static class DynamicSourceUnit {
|
|
public final GraftSource source;
|
|
public final MethodNode node;
|
|
|
|
private DynamicSourceUnit(GraftSource source, MethodNode node) {
|
|
this.source = source;
|
|
this.node = node;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (o == null || getClass() != o.getClass()) return false;
|
|
DynamicSourceUnit that = (DynamicSourceUnit) o;
|
|
return source.equals(that.source) && node.equals(that.node);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(source, node);
|
|
}
|
|
}
|
|
|
|
private static class MethodResolution {
|
|
public final MethodNode node;
|
|
public final boolean acceptReturn;
|
|
|
|
public MethodResolution(MethodNode node, boolean acceptReturn) {
|
|
this.node = node;
|
|
this.acceptReturn = acceptReturn;
|
|
}
|
|
}
|
|
}
|