mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-18 01:05:16 +00:00
Fix for some locals regressions from 0.8.3 and formalise locals strategy
This commit is contained in:
1 parent
89ecec1b48
commit
bc06e8bca6
9 files changed
+416
-42
No files matched your search
@@ -88,5 +88,33 @@ public interface IMixinConfig {
|
||||
* @return target classes of mixins in this config
|
||||
*/
|
||||
public abstract Set<String> getTargets();
|
||||
|
||||
/**
|
||||
* Decorate this config with arbitrary metadata for debugging or
|
||||
* compatibility purposes
|
||||
*
|
||||
* @param key meta key
|
||||
* @param value meta value
|
||||
* @param <V> value type
|
||||
* @throws IllegalArgumentException if the specified key exists already
|
||||
*/
|
||||
public abstract <V> void decorate(String key, V value);
|
||||
|
||||
/**
|
||||
* Get whether this node is decorated with the specified key
|
||||
*
|
||||
* @param key meta key
|
||||
* @return true if the specified decoration exists
|
||||
*/
|
||||
public abstract boolean hasDecoration(String key);
|
||||
|
||||
/**
|
||||
* Get the specified decoration
|
||||
*
|
||||
* @param key meta key
|
||||
* @param <V> value type
|
||||
* @return decoration value or null if absent
|
||||
*/
|
||||
public abstract <V> V getDecoration(String key);
|
||||
|
||||
}
|
||||
@@ -425,7 +425,7 @@ public class CallbackInjector extends Injector {
|
||||
|
||||
@Override
|
||||
protected void preInject(Target target, InjectionNode node) {
|
||||
if (this.localCapture.isCaptureLocals() || this.localCapture.isPrintLocals()) {
|
||||
if ((this.localCapture.isCaptureLocals() || this.localCapture.isPrintLocals()) && !node.hasDecoration(CallbackInjector.LOCALS_KEY)) {
|
||||
LocalVariableNode[] locals = Locals.getLocalsAt(this.classNode, target.method, node.getCurrentTarget());
|
||||
for (int j = 0; j < locals.length; j++) {
|
||||
if (locals[j] != null && locals[j].desc != null && locals[j].desc.startsWith("Lorg/spongepowered/asm/mixin/injection/callback/")) {
|
||||
|
||||
@@ -131,8 +131,8 @@ public class BeforeLoadLocal extends LocalVariableInjectionPoint {
|
||||
this.varNode = node;
|
||||
}
|
||||
|
||||
void check(Target target, Collection<AbstractInsnNode> nodes, AbstractInsnNode insn) {
|
||||
Context context = new Context(BeforeLoadLocal.this.returnType, BeforeLoadLocal.this.discriminator.isArgsOnly(), target, insn);
|
||||
void check(InjectionInfo info, Target target, Collection<AbstractInsnNode> nodes, AbstractInsnNode insn) {
|
||||
Context context = new Context(info, BeforeLoadLocal.this.returnType, BeforeLoadLocal.this.discriminator.isArgsOnly(), target, insn);
|
||||
int local = SearchState.INVALID_IMPLICIT;
|
||||
|
||||
try {
|
||||
@@ -207,13 +207,13 @@ public class BeforeLoadLocal extends LocalVariableInjectionPoint {
|
||||
while (iter.hasNext()) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
if (state.isPendingCheck()) {
|
||||
state.check(target, nodes, insn);
|
||||
state.check(info, target, nodes, insn);
|
||||
} else if (insn instanceof VarInsnNode && insn.getOpcode() == this.opcode && (this.ordinal == -1 || !state.success())) {
|
||||
state.register((VarInsnNode)insn);
|
||||
if (this.opcodeAfter) {
|
||||
state.setPendingCheck();
|
||||
} else {
|
||||
state.check(target, nodes, insn);
|
||||
state.check(info, target, nodes, insn);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+8
-1
@@ -36,6 +36,7 @@ import org.objectweb.asm.tree.AbstractInsnNode;
|
||||
import org.objectweb.asm.tree.AnnotationNode;
|
||||
import org.objectweb.asm.tree.LocalVariableNode;
|
||||
import org.spongepowered.asm.mixin.injection.modify.LocalVariableDiscriminator.Context.Local;
|
||||
import org.spongepowered.asm.mixin.injection.struct.InjectionInfo;
|
||||
import org.spongepowered.asm.mixin.injection.struct.Target;
|
||||
import org.spongepowered.asm.util.Bytecode;
|
||||
import org.spongepowered.asm.util.Annotations;
|
||||
@@ -100,6 +101,11 @@ public class LocalVariableDiscriminator {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Injection info
|
||||
*/
|
||||
final InjectionInfo info;
|
||||
|
||||
/**
|
||||
* Target method for this context
|
||||
*/
|
||||
@@ -132,7 +138,8 @@ public class LocalVariableDiscriminator {
|
||||
*/
|
||||
private final boolean isStatic;
|
||||
|
||||
public Context(Type returnType, boolean argsOnly, Target target, AbstractInsnNode node) {
|
||||
public Context(InjectionInfo info, Type returnType, boolean argsOnly, Target target, AbstractInsnNode node) {
|
||||
this.info = info;
|
||||
this.isStatic = Bytecode.isStatic(target.method);
|
||||
this.returnType = returnType;
|
||||
this.target = target;
|
||||
|
||||
+3
-3
@@ -67,8 +67,8 @@ public class ModifyVariableInjector extends Injector {
|
||||
*/
|
||||
final InsnList insns = new InsnList();
|
||||
|
||||
public Context(Type returnType, boolean argsOnly, Target target, AbstractInsnNode node) {
|
||||
super(returnType, argsOnly, target, node);
|
||||
public Context(InjectionInfo info, Type returnType, boolean argsOnly, Target target, AbstractInsnNode node) {
|
||||
super(info, returnType, argsOnly, target, node);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -156,7 +156,7 @@ public class ModifyVariableInjector extends Injector {
|
||||
if (node.hasDecoration(key)) {
|
||||
return; // already have a suitable context
|
||||
}
|
||||
Context context = new Context(this.returnType, this.discriminator.isArgsOnly(), target, node.getCurrentTarget());
|
||||
Context context = new Context(this.info, this.returnType, this.discriminator.isArgsOnly(), target, node.getCurrentTarget());
|
||||
node.<Context>decorate(key, context);
|
||||
}
|
||||
|
||||
|
||||
@@ -245,7 +245,7 @@ public final class ClassInfo {
|
||||
this.index = index;
|
||||
this.type = frameNode.type;
|
||||
this.locals = frameNode.local != null ? frameNode.local.size() : 0;
|
||||
this.size = Locals.computeFrameSize(frameNode);
|
||||
this.size = Locals.computeFrameSize(frameNode, initialFrameSize);
|
||||
}
|
||||
|
||||
/* (non-Javadoc)
|
||||
@@ -694,7 +694,7 @@ public final class ClassInfo {
|
||||
* Outer class name
|
||||
*/
|
||||
private final String outerName;
|
||||
|
||||
|
||||
/**
|
||||
* True if this in an inner class
|
||||
*/
|
||||
@@ -970,7 +970,7 @@ public final class ClassInfo {
|
||||
public boolean isPublic() {
|
||||
return (this.access & Opcodes.ACC_PUBLIC) != 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get whether this class is really public (only valid for inner classes
|
||||
* which may be "public" themselves but aren't actually visible because
|
||||
@@ -1032,7 +1032,7 @@ public final class ClassInfo {
|
||||
* Get whether this class is an inner class
|
||||
*/
|
||||
public boolean isInner() {
|
||||
return this.outerName != null;
|
||||
return this.isInner;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -383,6 +383,11 @@ final class MixinConfig implements Comparable<MixinConfig>, IMixinConfig {
|
||||
*/
|
||||
private transient int warnedClassVersion = 0;
|
||||
|
||||
/**
|
||||
* Service decorations on this config
|
||||
*/
|
||||
private transient Map<String, Object> decorations;
|
||||
|
||||
/**
|
||||
* Spawn via GSON, no public ctor for you
|
||||
*/
|
||||
@@ -1114,6 +1119,50 @@ final class MixinConfig implements Comparable<MixinConfig>, IMixinConfig {
|
||||
return Collections.<String>unmodifiableSet(this.unhandledTargets);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decorate this config with arbitrary metadata for debugging or
|
||||
* compatibility purposes
|
||||
*
|
||||
* @param key meta key
|
||||
* @param value meta value
|
||||
* @param <V> value type
|
||||
* @throws IllegalArgumentException if the specified key exists already
|
||||
*/
|
||||
@Override
|
||||
public <V> void decorate(String key, V value) {
|
||||
if (this.decorations == null) {
|
||||
this.decorations = new HashMap<String, Object>();
|
||||
}
|
||||
if (this.decorations.containsKey(key)) {
|
||||
throw new IllegalArgumentException(String.format("Decoration with key '%s' already exists on config %s", key, this));
|
||||
}
|
||||
this.decorations.put(key, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether this node is decorated with the specified key
|
||||
*
|
||||
* @param key meta key
|
||||
* @return true if the specified decoration exists
|
||||
*/
|
||||
@Override
|
||||
public boolean hasDecoration(String key) {
|
||||
return this.decorations != null && this.decorations.get(key) != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the specified decoration
|
||||
*
|
||||
* @param key meta key
|
||||
* @param <V> value type
|
||||
* @return decoration value or null if absent
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
public <V> V getDecoration(String key) {
|
||||
return (V) (this.decorations == null ? null : this.decorations.get(key));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the logging level for this config
|
||||
*/
|
||||
|
||||
@@ -1024,7 +1024,7 @@ class MixinInfo implements Comparable<MixinInfo>, IMixinInfo {
|
||||
return null;
|
||||
}
|
||||
this.type.validateTarget(target.name, targetInfo);
|
||||
if (target.isPrivate && targetInfo.isPublic() && !this.isVirtual()) {
|
||||
if (target.isPrivate && targetInfo.isReallyPublic() && !this.isVirtual()) {
|
||||
this.handleTargetError(String.format("@Mixin target %s is public in %s and should be specified in value", target.name, this), true);
|
||||
}
|
||||
return targetInfo;
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
package org.spongepowered.asm.util;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
@@ -68,6 +69,192 @@ public final class Locals {
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* A local variable entry which is "dead" (has been removed from the known
|
||||
* frame) but is being retained in the computed frame as a ghost so that we
|
||||
* can decide whether we want to include it in the final frame or not.
|
||||
*
|
||||
* <p>Zombie nodes are currently only persisted for 1 instruction, so in the
|
||||
* cases where there is a frame node followed directly by the candidate insn
|
||||
* the zombies will be returned as valid results, but otherwise culled.</p>
|
||||
*/
|
||||
static class ZombieLocalVariableNode extends LocalVariableNode {
|
||||
|
||||
static final char CHOP = 'C';
|
||||
static final char TRIM = 'X';
|
||||
|
||||
/**
|
||||
* Progenitor of this zombie, to allow "resurrection" (am I stretching
|
||||
* this metaphor too far?)
|
||||
*/
|
||||
final LocalVariableNode ancestor;
|
||||
|
||||
final char type;
|
||||
|
||||
/**
|
||||
* Number of instructions the zombie has "lived" for, incremented by the
|
||||
* state machine loop
|
||||
*/
|
||||
int lifetime;
|
||||
|
||||
/**
|
||||
* Number of frames which have elapsed for this zombie, incremented by
|
||||
* the state machine loop when a frame node is encountered
|
||||
*/
|
||||
int frames;
|
||||
|
||||
ZombieLocalVariableNode(LocalVariableNode ancestor, char type) {
|
||||
super(ancestor.name, ancestor.desc, ancestor.signature, ancestor.start, ancestor.end, ancestor.index);
|
||||
this.ancestor = ancestor;
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
boolean checkResurrect(Settings settings) {
|
||||
int insnThreshold = this.type == ZombieLocalVariableNode.CHOP ? settings.choppedInsnThreshold : settings.trimmedInsnThreshold;
|
||||
if (insnThreshold > -1 && this.lifetime > insnThreshold) {
|
||||
return false;
|
||||
}
|
||||
int frameThreshold = this.type == ZombieLocalVariableNode.CHOP ? settings.choppedFrameThreshold : settings.trimmedFrameThreshold;
|
||||
return frameThreshold == -1 || this.frames <= frameThreshold;
|
||||
}
|
||||
|
||||
static ZombieLocalVariableNode of(LocalVariableNode ancestor, char type) {
|
||||
if (ancestor instanceof ZombieLocalVariableNode) {
|
||||
return (ZombieLocalVariableNode)ancestor;
|
||||
}
|
||||
return ancestor != null ? new ZombieLocalVariableNode(ancestor, type) : null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return String.format("Z(%s,%-2d)", this.type, this.lifetime);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Settings for <tt>getLocalsAt</tt> containing the tunable options for the
|
||||
* algorithm. This exists for two purposes: Firstly, wrapping tunables up in
|
||||
* a single object for convenience, but secondly providing some level of
|
||||
* forward compatibility for platforms that which to provide <em>backward
|
||||
* </em> compatibility to their own consumers. The {@link #flagsCustom}
|
||||
* field is* provided as a way of encoding arbitrary options that downstream
|
||||
* projects may wish to use to tune their own implementations. The {@link
|
||||
* #flags} field is reserved for mixin internal flags to be added at a later
|
||||
* date.
|
||||
*/
|
||||
public static class Settings {
|
||||
|
||||
/**
|
||||
* When an incoming frame contains TOP entries, these are nearly always
|
||||
* bogus. If we previously knew the local in that slot, resurrect it.
|
||||
* Only resurrects TRIM zombies.
|
||||
*/
|
||||
public static int RESURRECT_FOR_BOGUS_TOP = 0x01;
|
||||
|
||||
/**
|
||||
* When a LOAD grows the frame, resurrect any zombies in the exposed
|
||||
* portion of the frame, based on the thresholds configured.
|
||||
*/
|
||||
public static int RESURRECT_EXPOSED_ON_LOAD = 0x02;
|
||||
|
||||
/**
|
||||
* When a STORE grows the frame, resurrect any zombies in the exposed
|
||||
* portion of the frame, based on the thresholds configured.
|
||||
*/
|
||||
public static int RESURRECT_EXPOSED_ON_STORE = 0x04;
|
||||
|
||||
/**
|
||||
* Default flags
|
||||
*/
|
||||
public static int DEFAULT_FLAGS = Settings.RESURRECT_FOR_BOGUS_TOP | Settings.RESURRECT_EXPOSED_ON_LOAD | Settings.RESURRECT_EXPOSED_ON_STORE;
|
||||
|
||||
/**
|
||||
* Default settings. CHOP zombies can be resurrected for 1 frame, TRIM
|
||||
* zombies can be resurrected forever
|
||||
*/
|
||||
public static Settings DEFAULT = new Settings(Settings.DEFAULT_FLAGS, 0, -1, 1, -1, -1);
|
||||
|
||||
/**
|
||||
* Reserved flags for Mixin
|
||||
*/
|
||||
final int flags;
|
||||
|
||||
/**
|
||||
* Platform-specific flags
|
||||
*/
|
||||
final int flagsCustom;
|
||||
|
||||
/**
|
||||
* Number of instructions that a CHOPped local is eligible for
|
||||
* resurrection, -1 to ignore, 0 for none
|
||||
*/
|
||||
final int choppedInsnThreshold;
|
||||
|
||||
/**
|
||||
* Number of frames that a CHOPped local is eligible for resurrection,
|
||||
* -1 to ignore, 0 for none
|
||||
*/
|
||||
final int choppedFrameThreshold;
|
||||
|
||||
/**
|
||||
* Number of instructions that a TRIMmed local is eligible for
|
||||
* resurrection, -1 to ignore, 0 for none
|
||||
*/
|
||||
final int trimmedInsnThreshold;
|
||||
|
||||
/**
|
||||
* Number of frames that a TRIMmed local is eligible for resurrection,
|
||||
* -1 to ignore, 0 for none
|
||||
*/
|
||||
final int trimmedFrameThreshold;
|
||||
|
||||
/**
|
||||
* @param flags Mixin flags
|
||||
* @param flagsCustom Platform-specific flags
|
||||
* @param insnThreshold Number of instructions that a local (regardless
|
||||
* of death reason) is eligible for resurrection, -1 to ignore,
|
||||
* 0 for none
|
||||
* @param frameThreshold Number of frames that a local (regardless of
|
||||
* death reason) is eligible for resurrection,-1 to ignore, 0 for
|
||||
* none
|
||||
*/
|
||||
public Settings(int flags, int flagsCustom, int insnThreshold, int frameThreshold) {
|
||||
this(flags, flagsCustom, insnThreshold, frameThreshold, insnThreshold, frameThreshold);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param flags Mixin flags
|
||||
* @param flagsCustom Platform-specific flags
|
||||
* @param choppedInsnThreshold Number of instructions that a CHOPped
|
||||
* local is eligible for resurrection, -1 to ignore, 0 for none
|
||||
* @param choppedFrameThreshold Number of frames that a CHOPped local is
|
||||
* eligible for resurrection,-1 to ignore, 0 for none
|
||||
* @param trimmedInsnThreshold Number of instructions that a TRIMmed#
|
||||
* local is eligible for resurrection, -1 to ignore, 0 for none
|
||||
* @param trimmedFrameThreshold Number of frames that a TRIMmed local is
|
||||
* eligible for resurrection, -1 to ignore, 0 for none
|
||||
*/
|
||||
public Settings(int flags, int flagsCustom, int choppedInsnThreshold, int choppedFrameThreshold, int trimmedInsnThreshold,
|
||||
int trimmedFrameThreshold) {
|
||||
this.flags = flags;
|
||||
this.flagsCustom = flagsCustom;
|
||||
this.choppedInsnThreshold = choppedInsnThreshold;
|
||||
this.choppedFrameThreshold = choppedFrameThreshold;
|
||||
this.trimmedInsnThreshold = trimmedInsnThreshold;
|
||||
this.trimmedFrameThreshold = trimmedFrameThreshold;
|
||||
}
|
||||
|
||||
boolean hasFlags(int flags) {
|
||||
return (this.flags & flags) == flags;
|
||||
}
|
||||
|
||||
boolean hasCustomFlags(int flagsCustom) {
|
||||
return (this.flagsCustom & flagsCustom) == flagsCustom;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Frame type names just for the purposes of debug printing
|
||||
*/
|
||||
@@ -145,6 +332,53 @@ public final class Locals {
|
||||
* specified location
|
||||
*/
|
||||
public static LocalVariableNode[] getLocalsAt(ClassNode classNode, MethodNode method, AbstractInsnNode node) {
|
||||
return Locals.getLocalsAt(classNode, method, node, Settings.DEFAULT);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Attempts to identify available locals at an arbitrary point in the
|
||||
* bytecode specified by node.</p>
|
||||
*
|
||||
* <p>This method builds an approximate view of the locals available at an
|
||||
* arbitrary point in the bytecode by examining the following features in
|
||||
* the bytecode:</p>
|
||||
* <ul>
|
||||
* <li>Any available stack map frames</li>
|
||||
* <li>STORE opcodes</li>
|
||||
* <li>The local variable table</li>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Inference proceeds by walking the bytecode from the start of the
|
||||
* method looking for stack frames and STORE opcodes. When either of these
|
||||
* is encountered, an attempt is made to cross-reference the values in the
|
||||
* stack map or STORE opcode with the value in the local variable table
|
||||
* which covers the code range. Stack map frames overwrite the entire
|
||||
* simulated local variable table with their own value types, STORE opcodes
|
||||
* overwrite only the local slot to which they pertain. Values in the
|
||||
* simulated locals array are spaced according to their size (unlike the
|
||||
* representation in FrameNode) and this TOP, NULL and UNINTITIALIZED_THIS
|
||||
* opcodes will be represented as null values in the simulated frame.</p>
|
||||
*
|
||||
* <p>This code does not currently simulate the prescribed JVM behaviour
|
||||
* where overwriting the second slot of a DOUBLE or LONG actually
|
||||
* invalidates the DOUBLE or LONG stored in the previous location, so we
|
||||
* have to hope (for now) that this behaviour isn't emitted by the compiler
|
||||
* or any upstream transformers. I may have to re-think this strategy if
|
||||
* this situation is encountered in the wild.</p>
|
||||
*
|
||||
* @param classNode ClassNode containing the method, used to initialise the
|
||||
* implicit "this" reference in simple methods with no stack frames
|
||||
* @param method MethodNode to explore
|
||||
* @param node Node indicating the position at which to determine the locals
|
||||
* state. The locals will be enumerated UP TO the specified node, so
|
||||
* bear in mind that if the specified node is itself a STORE opcode,
|
||||
* then we will be looking at the state of the locals PRIOR to its
|
||||
* invocation
|
||||
* @param settings Tunable settings for the state machine
|
||||
* @return A sparse array containing a view (hopefully) of the locals at the
|
||||
* specified location
|
||||
*/
|
||||
public static LocalVariableNode[] getLocalsAt(ClassNode classNode, MethodNode method, AbstractInsnNode node, Settings settings) {
|
||||
for (int i = 0; i < 3 && (node instanceof LabelNode || node instanceof LineNumberNode); i++) {
|
||||
AbstractInsnNode nextNode = Locals.nextNode(method.instructions, node);
|
||||
if (nextNode instanceof FrameNode) { // Do not ffwd over frames
|
||||
@@ -177,7 +411,7 @@ public final class Locals {
|
||||
local += argType.getSize();
|
||||
}
|
||||
|
||||
int initialFrameSize = local;
|
||||
final int initialFrameSize = local;
|
||||
int frameSize = local;
|
||||
int frameIndex = -1;
|
||||
int lastFrameSize = local;
|
||||
@@ -186,6 +420,18 @@ public final class Locals {
|
||||
|
||||
for (Iterator<AbstractInsnNode> iter = method.instructions.iterator(); iter.hasNext();) {
|
||||
AbstractInsnNode insn = iter.next();
|
||||
|
||||
// Tick the zombies
|
||||
for (int l = 0; l < frame.length; l++) {
|
||||
if (frame[l] instanceof ZombieLocalVariableNode) {
|
||||
ZombieLocalVariableNode zombie = (ZombieLocalVariableNode)frame[l];
|
||||
zombie.lifetime++;
|
||||
if (insn instanceof FrameNode) {
|
||||
zombie.frames++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (storeInsn != null) {
|
||||
LocalVariableNode storedLocal = Locals.getLocalVariableAt(classNode, method, insn, storeInsn.var);
|
||||
frame[storeInsn.var] = storedLocal;
|
||||
@@ -194,6 +440,9 @@ public final class Locals {
|
||||
&& Type.getType(storedLocal.desc).getSize() == 2) {
|
||||
frame[storeInsn.var + 1] = null; // TOP
|
||||
knownFrameSize = Math.max(knownFrameSize, storeInsn.var + 2);
|
||||
if (settings.hasFlags(Settings.RESURRECT_EXPOSED_ON_STORE)) {
|
||||
Locals.resurrect(frame, knownFrameSize, settings);
|
||||
}
|
||||
}
|
||||
storeInsn = null;
|
||||
}
|
||||
@@ -205,21 +454,21 @@ public final class Locals {
|
||||
break handleFrame;
|
||||
}
|
||||
|
||||
int frameNodeSize = Locals.computeFrameSize(frameNode);
|
||||
int frameNodeSize = Locals.computeFrameSize(frameNode, initialFrameSize);
|
||||
FrameData frameData = frameIndex < frames.size() ? frames.get(frameIndex) : null;
|
||||
|
||||
if (frameData != null) {
|
||||
if (frameData.type == Opcodes.F_FULL) {
|
||||
knownFrameSize = lastFrameSize = frameSize = Math.min(frameNodeSize, frameData.size);
|
||||
knownFrameSize = lastFrameSize = frameSize = Math.max(initialFrameSize, Math.min(frameNodeSize, frameData.size));
|
||||
} else {
|
||||
frameSize = Locals.getAdjustedFrameSize(frameSize, frameData);
|
||||
frameSize = Locals.getAdjustedFrameSize(frameSize, frameData, initialFrameSize);
|
||||
}
|
||||
} else {
|
||||
frameSize = Locals.getAdjustedFrameSize(frameSize, frameNode);
|
||||
frameSize = Locals.getAdjustedFrameSize(frameSize, frameNode, initialFrameSize);
|
||||
}
|
||||
|
||||
// Sanity check
|
||||
if (frameSize < 0) {
|
||||
if (frameSize < initialFrameSize) {
|
||||
throw new IllegalStateException(String.format("Locals entered an invalid state evaluating %s::%s%s at instruction %d (%s). "
|
||||
+ "Initial frame size is %d, calculated a frame size of %d with %s", classNode.name, method.name, method.desc,
|
||||
method.instructions.indexOf(insn), Bytecode.describeNode(insn, false), initialFrameSize, frameSize, frameData));
|
||||
@@ -228,7 +477,7 @@ public final class Locals {
|
||||
if ((frameData == null && (frameNode.type == Opcodes.F_CHOP || frameNode.type == Opcodes.F_NEW))
|
||||
|| (frameData != null && frameData.type == Opcodes.F_CHOP)) {
|
||||
for (int framePos = frameSize; framePos < frame.length; framePos++) {
|
||||
frame[framePos] = null;
|
||||
frame[framePos] = ZombieLocalVariableNode.of(frame[framePos], ZombieLocalVariableNode.CHOP);
|
||||
}
|
||||
knownFrameSize = lastFrameSize = frameSize;
|
||||
break handleFrame;
|
||||
@@ -249,7 +498,14 @@ public final class Locals {
|
||||
boolean is32bitValue = localType == Opcodes.INTEGER || localType == Opcodes.FLOAT;
|
||||
boolean is64bitValue = localType == Opcodes.DOUBLE || localType == Opcodes.LONG;
|
||||
if (localType == Opcodes.TOP) {
|
||||
// Do nothing, explicit TOP entries are pretty much always bogus, and real ones are handled below
|
||||
// Explicit TOP entries are pretty much always bogus, but depending on our resurrection
|
||||
// strategy we may want to resurrect eligible zombies here. Real TOP entries are handled below
|
||||
if (frame[framePos] instanceof ZombieLocalVariableNode && settings.hasFlags(Settings.RESURRECT_FOR_BOGUS_TOP)) {
|
||||
ZombieLocalVariableNode zombie = (ZombieLocalVariableNode)frame[framePos];
|
||||
if (zombie.type == ZombieLocalVariableNode.TRIM) {
|
||||
frame[framePos] = zombie.ancestor;
|
||||
}
|
||||
}
|
||||
} else if (isMarkerType) {
|
||||
frame[framePos] = null;
|
||||
} else if (is32bitValue || is64bitValue) {
|
||||
@@ -268,7 +524,7 @@ public final class Locals {
|
||||
if (framePos < knownFrameSize) {
|
||||
frame[framePos] = Locals.getLocalVariableAt(classNode, method, insn, framePos);
|
||||
} else {
|
||||
frame[framePos] = null;
|
||||
frame[framePos] = ZombieLocalVariableNode.of(frame[framePos], ZombieLocalVariableNode.TRIM);
|
||||
}
|
||||
}
|
||||
} else if (localType instanceof LabelNode) {
|
||||
@@ -279,17 +535,20 @@ public final class Locals {
|
||||
}
|
||||
}
|
||||
} else if (insn instanceof VarInsnNode) {
|
||||
VarInsnNode varNode = (VarInsnNode) insn;
|
||||
VarInsnNode varInsn = (VarInsnNode)insn;
|
||||
boolean isLoad = insn.getOpcode() >= Opcodes.ILOAD && insn.getOpcode() <= Opcodes.SALOAD;
|
||||
if (isLoad) {
|
||||
frame[varNode.var] = Locals.getLocalVariableAt(classNode, method, insn, varNode.var);
|
||||
int varSize = frame[varNode.var].desc != null ? Type.getType(frame[varNode.var].desc).getSize() : 1;
|
||||
knownFrameSize = Math.max(knownFrameSize, varNode.var + varSize);
|
||||
frame[varInsn.var] = Locals.getLocalVariableAt(classNode, method, insn, varInsn.var);
|
||||
int varSize = frame[varInsn.var].desc != null ? Type.getType(frame[varInsn.var].desc).getSize() : 1;
|
||||
knownFrameSize = Math.max(knownFrameSize, varInsn.var + varSize);
|
||||
if (settings.hasFlags(Settings.RESURRECT_EXPOSED_ON_LOAD)) {
|
||||
Locals.resurrect(frame, knownFrameSize, settings);
|
||||
}
|
||||
} else {
|
||||
// Update the LVT for the opcode AFTER this one, since we always want to know
|
||||
// the frame state BEFORE the *current* instruction to match the contract of
|
||||
// injection points
|
||||
storeInsn = varNode;
|
||||
storeInsn = varInsn;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -297,10 +556,18 @@ public final class Locals {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Null out any "unknown" or mixin-provided locals
|
||||
for (int l = 0; l < frame.length; l++) {
|
||||
if (frame[l] != null && frame[l].desc == null || frame[l] instanceof SyntheticLocalVariableNode) {
|
||||
if (frame[l] instanceof ZombieLocalVariableNode) {
|
||||
ZombieLocalVariableNode zombie = (ZombieLocalVariableNode)frame[l];
|
||||
// preserve zombies where the frame node which culled them was immediately prior to
|
||||
// the matched instruction, or *was itself* the matched instruction, the returned
|
||||
// frame will contain the original node (the zombie ancestor)
|
||||
frame[l] = (zombie.lifetime > 1) ? null : zombie.ancestor;
|
||||
}
|
||||
|
||||
if ((frame[l] != null && frame[l].desc == null) || frame[l] instanceof SyntheticLocalVariableNode) {
|
||||
frame[l] = null;
|
||||
}
|
||||
}
|
||||
@@ -308,6 +575,25 @@ public final class Locals {
|
||||
return frame;
|
||||
}
|
||||
|
||||
/**
|
||||
* Walks the supplied <tt>frame</tt> up to the specified <tt>knownFrameSize
|
||||
* </tt> and resurrects any zombies that meet the required criteria
|
||||
*
|
||||
* @param frame Frame to walk
|
||||
* @param knownFrameSize Known frame size in which to resurrect
|
||||
* @param settings Resurrection settings
|
||||
*/
|
||||
private static void resurrect(LocalVariableNode[] frame, int knownFrameSize, Settings settings) {
|
||||
for (int l = 0; l < knownFrameSize && l < frame.length; l++) {
|
||||
if (frame[l] instanceof ZombieLocalVariableNode) {
|
||||
ZombieLocalVariableNode zombie = (ZombieLocalVariableNode)frame[l];
|
||||
if (zombie.checkResurrect(settings)) {
|
||||
frame[l] = zombie.ancestor;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to locate the appropriate entry in the local variable table for
|
||||
* the specified local variable index at the location specified by node.
|
||||
@@ -380,7 +666,7 @@ public final class Locals {
|
||||
if (method.localVariables.isEmpty()) {
|
||||
return Locals.getGeneratedLocalVariableTable(classNode, method);
|
||||
}
|
||||
return method.localVariables;
|
||||
return Collections.<LocalVariableNode>unmodifiableList(method.localVariables);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -399,7 +685,7 @@ public final class Locals {
|
||||
|
||||
localVars = Locals.generateLocalVariableTable(classNode, method);
|
||||
Locals.calculatedLocalVariables.put(methodId, localVars);
|
||||
return localVars;
|
||||
return Collections.<LocalVariableNode>unmodifiableList(localVars);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -548,10 +834,11 @@ public final class Locals {
|
||||
*
|
||||
* @param currentSize current frame size
|
||||
* @param frameNode frame entry
|
||||
* @param initialFrameSize Method initial frame size
|
||||
* @return new frame size
|
||||
*/
|
||||
private static int getAdjustedFrameSize(int currentSize, FrameNode frameNode) {
|
||||
return Locals.getAdjustedFrameSize(currentSize, frameNode.type, Locals.computeFrameSize(frameNode));
|
||||
private static int getAdjustedFrameSize(int currentSize, FrameNode frameNode, int initialFrameSize) {
|
||||
return Locals.getAdjustedFrameSize(currentSize, frameNode.type, Locals.computeFrameSize(frameNode, initialFrameSize), initialFrameSize);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -561,10 +848,11 @@ public final class Locals {
|
||||
*
|
||||
* @param currentSize current frame size
|
||||
* @param frameData frame entry
|
||||
* @param initialFrameSize Method initial frame size
|
||||
* @return new frame size
|
||||
*/
|
||||
private static int getAdjustedFrameSize(int currentSize, FrameData frameData) {
|
||||
return Locals.getAdjustedFrameSize(currentSize, frameData.type, frameData.size);
|
||||
private static int getAdjustedFrameSize(int currentSize, FrameData frameData, int initialFrameSize) {
|
||||
return Locals.getAdjustedFrameSize(currentSize, frameData.type, frameData.size, initialFrameSize);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -575,17 +863,18 @@ public final class Locals {
|
||||
* @param currentSize current frame size
|
||||
* @param type frame entry type
|
||||
* @param size frame entry size
|
||||
* @param initialFrameSize Method initial frame size
|
||||
* @return new frame size
|
||||
*/
|
||||
private static int getAdjustedFrameSize(int currentSize, int type, int size) {
|
||||
private static int getAdjustedFrameSize(int currentSize, int type, int size, int initialFrameSize) {
|
||||
switch (type) {
|
||||
case Opcodes.F_NEW:
|
||||
case Opcodes.F_FULL:
|
||||
return size;
|
||||
return Math.max(initialFrameSize, size);
|
||||
case Opcodes.F_APPEND:
|
||||
return currentSize + size;
|
||||
case Opcodes.F_CHOP:
|
||||
return currentSize - size;
|
||||
return Math.max(initialFrameSize, currentSize - size);
|
||||
case Opcodes.F_SAME:
|
||||
case Opcodes.F_SAME1:
|
||||
return currentSize;
|
||||
@@ -599,11 +888,12 @@ public final class Locals {
|
||||
* supplied frame node
|
||||
*
|
||||
* @param frameNode frame node with locals to compute
|
||||
* @param initialFrameSize Method initial frame size
|
||||
* @return size of frame node locals
|
||||
*/
|
||||
public static int computeFrameSize(FrameNode frameNode) {
|
||||
public static int computeFrameSize(FrameNode frameNode, int initialFrameSize) {
|
||||
if (frameNode.local == null) {
|
||||
return 0;
|
||||
return initialFrameSize;
|
||||
}
|
||||
int size = 0;
|
||||
for (Object local : frameNode.local) {
|
||||
@@ -613,7 +903,7 @@ public final class Locals {
|
||||
size++;
|
||||
}
|
||||
}
|
||||
return size;
|
||||
return Math.max(initialFrameSize, size);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Reference in new issue
Block a user