Skip to content

Commit a8e8098

Browse files
raphwraphw
committed
Allow stack aware method visitor to adjust its state when reading frames.
1 parent 4d02893 commit a8e8098

File tree

3 files changed

+221
-4
lines changed

3 files changed

+221
-4
lines changed

‎byte-buddy-dep/src/main/java/net/bytebuddy/asm/Advice.java

+2-2
Original file line numberDiff line numberDiff line change
@@ -9223,7 +9223,7 @@ protected CodeTranslationVisitor(MethodVisitor methodVisitor,
92239223
StackManipulation exceptionHandler,
92249224
PostProcessor postProcessor,
92259225
boolean exit) {
9226-
super(OpenedClassReader.ASM_API, new StackAwareMethodVisitor(methodVisitor, instrumentedMethod));
9226+
super(OpenedClassReader.ASM_API, StackAwareMethodVisitor.of(methodVisitor, instrumentedMethod));
92279227
this.methodVisitor = methodVisitor;
92289228
this.implementationContext = implementationContext;
92299229
this.argumentHandler = argumentHandler;
@@ -10763,7 +10763,7 @@ protected WithExitAdvice(MethodVisitor methodVisitor,
1076310763
List<? extends TypeDescription> postMethodTypes,
1076410764
int writerFlags,
1076510765
int readerFlags) {
10766-
super(new StackAwareMethodVisitor(methodVisitor, instrumentedMethod),
10766+
super(StackAwareMethodVisitor.of(methodVisitor, instrumentedMethod),
1076710767
implementationContext,
1076810768
assigner,
1076910769
exceptionHandler,

‎byte-buddy-dep/src/main/java/net/bytebuddy/utility/visitor/StackAwareMethodVisitor.java

+101-1
Original file line numberDiff line numberDiff line change
@@ -16,21 +16,60 @@
1616
package net.bytebuddy.utility.visitor;
1717

1818
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
19+
import net.bytebuddy.build.AccessControllerPlugin;
1920
import net.bytebuddy.description.method.MethodDescription;
2021
import net.bytebuddy.implementation.bytecode.StackSize;
2122
import net.bytebuddy.utility.CompoundList;
2223
import net.bytebuddy.utility.OpenedClassReader;
2324
import net.bytebuddy.utility.nullability.MaybeNull;
25+
import net.bytebuddy.utility.privilege.GetSystemPropertyAction;
2426
import org.objectweb.asm.*;
2527

28+
import java.security.PrivilegedAction;
2629
import java.util.*;
2730

2831
/**
32+
* <p>
2933
* A method visitor that is aware of the current size of the operand stack at all times. Additionally, this method takes
3034
* care of maintaining an index for the next currently unused index of the local variable array.
35+
* </p>
36+
* <p>
37+
* <b>Important</b>: It is not always possible to apply this method visitor if it is applied to a class file compiled
38+
* for Java 5 or earlier, or if frames are computed by ASM and not passed to this visitor, if a method also contains
39+
* {@link Opcodes#GOTO} instructions. In the latter case, the stack is assumed empty after the instruction. If this
40+
* is a problem, stack adjustment can be disabled by setting {@link StackAwareMethodVisitor#UNADJUSTED_PROPERTY} to
41+
* {@code true}. With this setting, Byte Buddy does no longer attempt draining non-empty stacks and skips this visitor
42+
* in all cases. This might however lead to verification problems if stacks are left non-empty. As the latter happens
43+
* more common and since this visitor is applied defensively, using this wrapper is considered the more sensible default.
44+
* </p>
3145
*/
3246
public class StackAwareMethodVisitor extends MethodVisitor {
3347

48+
/**
49+
* A property to disable stack adjustment. Stack adjustment is typically needed when instrumenting other
50+
* generated code that leaves excess values on the stack. This is also often the case when byte code
51+
* obfuscation is used.
52+
*/
53+
public static final String UNADJUSTED_PROPERTY = "net.bytebuddy.unadjusted";
54+
55+
/**
56+
* {@code true} if stack adjustment is disabled.
57+
*/
58+
public static final boolean UNADJUSTED;
59+
60+
/*
61+
* Reads the raw type property.
62+
*/
63+
static {
64+
boolean disabled;
65+
try {
66+
disabled = Boolean.parseBoolean(doPrivileged(new GetSystemPropertyAction(UNADJUSTED_PROPERTY)));
67+
} catch (Exception ignored) {
68+
disabled = false;
69+
}
70+
UNADJUSTED = disabled;
71+
}
72+
3473
/**
3574
* An array mapping any opcode to its size impact onto the operand stack. This mapping is taken from
3675
* {@link org.objectweb.asm.Frame} with the difference that the {@link Opcodes#JSR} instruction is
@@ -74,13 +113,38 @@ public class StackAwareMethodVisitor extends MethodVisitor {
74113
* @param methodVisitor The method visitor to delegate operations to.
75114
* @param instrumentedMethod The method description for which this method visitor is applied.
76115
*/
77-
public StackAwareMethodVisitor(MethodVisitor methodVisitor, MethodDescription instrumentedMethod) {
116+
protected StackAwareMethodVisitor(MethodVisitor methodVisitor, MethodDescription instrumentedMethod) {
78117
super(OpenedClassReader.ASM_API, methodVisitor);
79118
current = new ArrayList<StackSize>();
80119
sizes = new HashMap<Label, List<StackSize>>();
81120
freeIndex = instrumentedMethod.getStackSize();
82121
}
83122

123+
/**
124+
* Wraps the provided method visitor within a stack aware method visitor.
125+
*
126+
* @param methodVisitor The method visitor to delegate operations to.
127+
* @param instrumentedMethod The method description for which this method visitor is applied.
128+
* @return An appropriate
129+
*/
130+
public static MethodVisitor of(MethodVisitor methodVisitor, MethodDescription instrumentedMethod) {
131+
return UNADJUSTED
132+
? methodVisitor
133+
: new StackAwareMethodVisitor(methodVisitor, instrumentedMethod);
134+
}
135+
136+
/**
137+
* A proxy for {@code java.security.AccessController#doPrivileged} that is activated if available.
138+
*
139+
* @param action The action to execute from a privileged context.
140+
* @param <T> The type of the action's resolved value.
141+
* @return The action's resolved value.
142+
*/
143+
@AccessControllerPlugin.Enhance
144+
private static <T> T doPrivileged(PrivilegedAction<T> action) {
145+
return action.run();
146+
}
147+
84148
/**
85149
* Adjusts the current state of the operand stack.
86150
*
@@ -146,6 +210,9 @@ public void drainStack() {
146210
* @return The minimal size of the local variable array that is required to perform the operation.
147211
*/
148212
public int drainStack(int store, int load, StackSize size) {
213+
if (current.isEmpty()) {
214+
return 0;
215+
}
149216
int difference = current.get(current.size() - 1).getSize() - size.getSize();
150217
if (current.size() == 1 && difference == 0) {
151218
return 0;
@@ -376,4 +443,37 @@ public void visitTryCatchBlock(Label start, Label end, Label handler, @MaybeNull
376443
sizes.put(handler, Collections.singletonList(StackSize.SINGLE));
377444
super.visitTryCatchBlock(start, end, handler, type);
378445
}
446+
447+
@Override
448+
public void visitFrame(int type, int localVariableLength, @MaybeNull Object[] localVariable, int stackSize, @MaybeNull Object[] stack) {
449+
switch (type) {
450+
case Opcodes.F_SAME:
451+
case Opcodes.F_CHOP:
452+
case Opcodes.F_APPEND:
453+
current.clear();
454+
break;
455+
case Opcodes.F_SAME1:
456+
current.clear();
457+
if (stack[0] == Opcodes.LONG || stack[0] == Opcodes.DOUBLE) {
458+
current.add(StackSize.DOUBLE);
459+
} else {
460+
current.add(StackSize.SINGLE);
461+
}
462+
break;
463+
case Opcodes.F_NEW:
464+
case Opcodes.F_FULL:
465+
current.clear();
466+
for (int index = 0; index < stackSize; index++) {
467+
if (stack[index] == Opcodes.LONG || stack[index] == Opcodes.DOUBLE) {
468+
current.add(StackSize.DOUBLE);
469+
} else {
470+
current.add(StackSize.SINGLE);
471+
}
472+
}
473+
break;
474+
default:
475+
throw new IllegalStateException("Unknown frame type: " + type);
476+
}
477+
super.visitFrame(type, localVariableLength, localVariable, stackSize, stack);
478+
}
379479
}

‎byte-buddy-dep/src/test/java/net/bytebuddy/utility/visitor/StackAwareMethodVisitorTest.java

+118-1
Original file line numberDiff line numberDiff line change
@@ -149,4 +149,121 @@ public void testStackCanUnderflow() throws Exception {
149149
verify(this.methodVisitor).visitInsn(Opcodes.POP);
150150
verifyNoMoreInteractions(this.methodVisitor);
151151
}
152-
}
152+
153+
@Test
154+
public void testStackFrameSame() {
155+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
156+
methodVisitor.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
157+
methodVisitor.drainStack();
158+
verify(this.methodVisitor).visitFrame(Opcodes.F_SAME, 0, null, 0, null);
159+
verifyNoMoreInteractions(this.methodVisitor);
160+
}
161+
162+
@Test
163+
public void testStackFrameChop() {
164+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
165+
methodVisitor.visitFrame(Opcodes.F_CHOP, 0, null, 0, null);
166+
methodVisitor.drainStack();
167+
verify(this.methodVisitor).visitFrame(Opcodes.F_CHOP, 0, null, 0, null);
168+
verifyNoMoreInteractions(this.methodVisitor);
169+
}
170+
171+
@Test
172+
public void testStackFrameAppend() {
173+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
174+
methodVisitor.visitFrame(Opcodes.F_APPEND, 0, null, 0, null);
175+
methodVisitor.drainStack();
176+
verify(this.methodVisitor).visitFrame(Opcodes.F_APPEND, 0, null, 0, null);
177+
verifyNoMoreInteractions(this.methodVisitor);
178+
}
179+
180+
@Test
181+
public void testStackFrameSame1OnInteger() {
182+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
183+
methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.INTEGER});
184+
methodVisitor.drainStack();
185+
verify(this.methodVisitor).visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.INTEGER});
186+
verify(this.methodVisitor).visitInsn(Opcodes.POP);
187+
verifyNoMoreInteractions(this.methodVisitor);
188+
}
189+
190+
@Test
191+
public void testStackFrameSame1OnLong() {
192+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
193+
methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.LONG});
194+
methodVisitor.drainStack();
195+
verify(this.methodVisitor).visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.LONG});
196+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
197+
verifyNoMoreInteractions(this.methodVisitor);
198+
}
199+
200+
@Test
201+
public void testStackFrameSame1OnDouble() {
202+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
203+
methodVisitor.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.DOUBLE});
204+
methodVisitor.drainStack();
205+
verify(this.methodVisitor).visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {Opcodes.DOUBLE});
206+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
207+
verifyNoMoreInteractions(this.methodVisitor);
208+
}
209+
210+
@Test
211+
public void testStackFrameFullOnInteger() {
212+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
213+
methodVisitor.visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.INTEGER});
214+
methodVisitor.drainStack();
215+
verify(this.methodVisitor).visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.INTEGER});
216+
verify(this.methodVisitor).visitInsn(Opcodes.POP);
217+
verifyNoMoreInteractions(this.methodVisitor);
218+
}
219+
220+
@Test
221+
public void testStackFrameFullOnLong() {
222+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
223+
methodVisitor.visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.LONG});
224+
methodVisitor.drainStack();
225+
verify(this.methodVisitor).visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.LONG});
226+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
227+
verifyNoMoreInteractions(this.methodVisitor);
228+
}
229+
230+
@Test
231+
public void testStackFrameFullOnDouble() {
232+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
233+
methodVisitor.visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.DOUBLE});
234+
methodVisitor.drainStack();
235+
verify(this.methodVisitor).visitFrame(Opcodes.F_FULL, 0, null, 1, new Object[] {Opcodes.DOUBLE});
236+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
237+
verifyNoMoreInteractions(this.methodVisitor);
238+
}
239+
240+
@Test
241+
public void testStackFrameNewOnInteger() {
242+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
243+
methodVisitor.visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.INTEGER});
244+
methodVisitor.drainStack();
245+
verify(this.methodVisitor).visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.INTEGER});
246+
verify(this.methodVisitor).visitInsn(Opcodes.POP);
247+
verifyNoMoreInteractions(this.methodVisitor);
248+
}
249+
250+
@Test
251+
public void testStackFrameNewOnLong() {
252+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
253+
methodVisitor.visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.LONG});
254+
methodVisitor.drainStack();
255+
verify(this.methodVisitor).visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.LONG});
256+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
257+
verifyNoMoreInteractions(this.methodVisitor);
258+
}
259+
260+
@Test
261+
public void testStackFrameNewOnDouble() {
262+
StackAwareMethodVisitor methodVisitor = new StackAwareMethodVisitor(this.methodVisitor, methodDescription);
263+
methodVisitor.visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.DOUBLE});
264+
methodVisitor.drainStack();
265+
verify(this.methodVisitor).visitFrame(Opcodes.F_NEW, 0, null, 1, new Object[] {Opcodes.DOUBLE});
266+
verify(this.methodVisitor).visitInsn(Opcodes.POP2);
267+
verifyNoMoreInteractions(this.methodVisitor);
268+
}
269+
}

0 commit comments

Comments
 (0)