| /*** |
| * ASM tests |
| * Copyright (c) 2000-2011 INRIA, France Telecom |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| * THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| package org.objectweb.asm.commons; |
| |
| import junit.framework.TestCase; |
| |
| import org.objectweb.asm.ClassWriter; |
| import org.objectweb.asm.Label; |
| import org.objectweb.asm.MethodVisitor; |
| import org.objectweb.asm.Opcodes; |
| import org.objectweb.asm.tree.MethodNode; |
| import org.objectweb.asm.util.TraceMethodVisitor; |
| import org.objectweb.asm.util.Textifier; |
| |
| /** |
| * JsrInlinerTest |
| * |
| * @author Eugene Kuleshov, Niko Matsakis, Eric Bruneton |
| */ |
| public class JSRInlinerAdapterUnitTest extends TestCase { |
| |
| private JSRInlinerAdapter jsr; |
| private MethodNode exp; |
| private MethodVisitor current; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| jsr = new JSRInlinerAdapter(null, 0, "m", "()V", null, null) { |
| @Override |
| public void visitEnd() { |
| System.err.println("started w/ method:" + name); |
| Textifier t = new Textifier(); |
| TraceMethodVisitor mv = new TraceMethodVisitor(t); |
| for (int i = 0; i < instructions.size(); ++i) { |
| instructions.get(i).accept(mv); |
| System.err.print(Integer.toString(i + 100000).substring(1)); |
| System.err.print(" : " + t.text.get(i)); |
| } |
| super.visitEnd(); |
| System.err.println("finished w/ method:" + name); |
| } |
| }; |
| exp = new MethodNode(0, "m", "()V", null, null); |
| } |
| |
| private void setCurrent(final MethodVisitor cv) { |
| this.current = cv; |
| } |
| |
| private void ICONST_0() { |
| this.current.visitInsn(Opcodes.ICONST_0); |
| } |
| |
| private void ISTORE(final int var) { |
| this.current.visitVarInsn(Opcodes.ISTORE, var); |
| } |
| |
| private void ALOAD(final int var) { |
| this.current.visitVarInsn(Opcodes.ALOAD, var); |
| } |
| |
| private void ILOAD(final int var) { |
| this.current.visitVarInsn(Opcodes.ILOAD, var); |
| } |
| |
| private void ASTORE(final int var) { |
| this.current.visitVarInsn(Opcodes.ASTORE, var); |
| } |
| |
| private void RET(final int var) { |
| this.current.visitVarInsn(Opcodes.RET, var); |
| } |
| |
| private void ATHROW() { |
| this.current.visitInsn(Opcodes.ATHROW); |
| } |
| |
| private void ACONST_NULL() { |
| this.current.visitInsn(Opcodes.ACONST_NULL); |
| } |
| |
| private void RETURN() { |
| this.current.visitInsn(Opcodes.RETURN); |
| } |
| |
| private void LABEL(final Label l) { |
| this.current.visitLabel(l); |
| } |
| |
| private void IINC(final int var, final int amnt) { |
| this.current.visitIincInsn(var, amnt); |
| } |
| |
| private void GOTO(final Label l) { |
| this.current.visitJumpInsn(Opcodes.GOTO, l); |
| } |
| |
| private void JSR(final Label l) { |
| this.current.visitJumpInsn(Opcodes.JSR, l); |
| } |
| |
| private void IFNONNULL(final Label l) { |
| this.current.visitJumpInsn(Opcodes.IFNONNULL, l); |
| } |
| |
| private void IFNE(final Label l) { |
| this.current.visitJumpInsn(Opcodes.IFNE, l); |
| } |
| |
| private void TRYCATCH(final Label start, final Label end, |
| final Label handler) { |
| this.current.visitTryCatchBlock(start, end, handler, null); |
| } |
| |
| private void LINE(final int line, final Label start) { |
| this.current.visitLineNumber(line, start); |
| } |
| |
| private void LOCALVAR(final String name, final String desc, |
| final int index, final Label start, final Label end) { |
| this.current.visitLocalVariable(name, desc, null, start, end, index); |
| } |
| |
| private void END(final int maxStack, final int maxLocals) { |
| this.current.visitMaxs(maxStack, maxLocals); |
| this.current.visitEnd(); |
| ClassWriter cw = new ClassWriter(0); |
| cw.visit(Opcodes.V1_1, Opcodes.ACC_PUBLIC, "C", null, |
| "java/lang/Object", null); |
| MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", |
| null, null); |
| mv.visitCode(); |
| mv.visitVarInsn(Opcodes.ALOAD, 0); |
| mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", |
| "()V"); |
| mv.visitInsn(Opcodes.RETURN); |
| mv.visitMaxs(1, 1); |
| mv.visitEnd(); |
| ((MethodNode) this.current).accept(cw); |
| cw.visitEnd(); |
| byte[] b = cw.toByteArray(); |
| try { |
| TestClassLoader loader = new TestClassLoader(); |
| Class<?> c = loader.defineClass("C", b); |
| c.newInstance(); |
| } catch (Throwable t) { |
| fail(t.getMessage()); |
| } |
| this.current = null; |
| } |
| |
| static class TestClassLoader extends ClassLoader { |
| |
| public Class<?> defineClass(final String name, final byte[] b) { |
| return defineClass(name, b, 0, b.length); |
| } |
| } |
| |
| /** |
| * Tests a method which has the most basic <code>try{}finally</code> form |
| * imaginable: |
| * |
| * <pre> |
| * public void a() { |
| * int a = 0; |
| * try { |
| * a++; |
| * } finally { |
| * a--; |
| * } |
| * } |
| * </pre> |
| */ |
| public void testBasic() { |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| /* L0: body of try block */ |
| LABEL(L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| /* L2: exception handler */ |
| LABEL(L2); |
| ASTORE(3); |
| JSR(L3); |
| ALOAD(3); |
| ATHROW(); |
| |
| /* L3: subroutine */ |
| LABEL(L3); |
| ASTORE(2); |
| IINC(1, -1); |
| RET(2); |
| |
| /* L1: non-exceptional exit from try block */ |
| LABEL(L1); |
| JSR(L3); |
| LABEL(L4); // L4 |
| RETURN(); |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L4, L2); |
| |
| END(1, 4); |
| } |
| |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3_1a = new Label(); |
| Label L3_1b = new Label(); |
| Label L3_2a = new Label(); |
| Label L3_2b = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(exp); |
| ICONST_0(); |
| ISTORE(1); |
| // L0: try/catch block |
| LABEL(L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| // L2: Exception handler: |
| LABEL(L2); |
| ASTORE(3); |
| ACONST_NULL(); |
| GOTO(L3_1a); |
| LABEL(L3_1b); // L3_1b; |
| ALOAD(3); |
| ATHROW(); |
| |
| // L1: On non-exceptional exit, try block leads here: |
| LABEL(L1); |
| ACONST_NULL(); |
| GOTO(L3_2a); |
| LABEL(L3_2b); // L3_2b |
| LABEL(L4); // L4 |
| RETURN(); |
| |
| // L3_1a: First instantiation of subroutine: |
| LABEL(L3_1a); |
| ASTORE(2); |
| IINC(1, -1); |
| GOTO(L3_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L3_2a: Second instantiation of subroutine: |
| LABEL(L3_2a); |
| ASTORE(2); |
| IINC(1, -1); |
| GOTO(L3_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L4, L2); |
| |
| END(1, 4); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * Tests a method which has an if/else-if w/in the finally clause: |
| * |
| * <pre> |
| * public void a() { |
| * int a = 0; |
| * try { |
| * a++; |
| * } finally { |
| * if (a == 0) |
| * a += 2; |
| * else |
| * a += 3; |
| * } |
| * } |
| * </pre> |
| */ |
| public void testIfElseInFinally() { |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| Label L5 = new Label(); |
| Label L6 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| /* L0: body of try block */ |
| LABEL(L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| /* L2: exception handler */ |
| LABEL(L2); |
| ASTORE(3); |
| JSR(L3); |
| ALOAD(3); |
| ATHROW(); |
| |
| /* L3: subroutine */ |
| LABEL(L3); |
| ASTORE(2); |
| ILOAD(1); |
| IFNE(L4); |
| IINC(1, 2); |
| GOTO(L5); |
| LABEL(L4); // L4: a != 0 |
| IINC(1, 3); |
| LABEL(L5); // L5: common exit |
| RET(2); |
| |
| /* L1: non-exceptional exit from try block */ |
| LABEL(L1); |
| JSR(L3); |
| LABEL(L6); // L6 is used in the TRYCATCH below |
| RETURN(); |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L6, L2); |
| |
| END(1, 4); |
| } |
| |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3_1a = new Label(); |
| Label L3_1b = new Label(); |
| Label L3_2a = new Label(); |
| Label L3_2b = new Label(); |
| Label L4_1 = new Label(); |
| Label L4_2 = new Label(); |
| Label L5_1 = new Label(); |
| Label L5_2 = new Label(); |
| Label L6 = new Label(); |
| |
| setCurrent(exp); |
| ICONST_0(); |
| ISTORE(1); |
| // L0: try/catch block |
| LABEL(L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| // L2: Exception handler: |
| LABEL(L2); |
| ASTORE(3); |
| ACONST_NULL(); |
| GOTO(L3_1a); |
| LABEL(L3_1b); // L3_1b; |
| ALOAD(3); |
| ATHROW(); |
| |
| // L1: On non-exceptional exit, try block leads here: |
| LABEL(L1); |
| ACONST_NULL(); |
| GOTO(L3_2a); |
| LABEL(L3_2b); // L3_2b |
| LABEL(L6); // L6 |
| RETURN(); |
| |
| // L3_1a: First instantiation of subroutine: |
| LABEL(L3_1a); |
| ASTORE(2); |
| ILOAD(1); |
| IFNE(L4_1); |
| IINC(1, 2); |
| GOTO(L5_1); |
| LABEL(L4_1); // L4_1: a != 0 |
| IINC(1, 3); |
| LABEL(L5_1); // L5_1: common exit |
| GOTO(L3_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L3_2a: First instantiation of subroutine: |
| LABEL(L3_2a); |
| ASTORE(2); |
| ILOAD(1); |
| IFNE(L4_2); |
| IINC(1, 2); |
| GOTO(L5_2); |
| LABEL(L4_2); // L4_2: a != 0 |
| IINC(1, 3); |
| LABEL(L5_2); // L5_2: common exit |
| GOTO(L3_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L6, L2); |
| |
| END(1, 4); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * Tests a simple nested finally: |
| * |
| * <pre> |
| * public void a1() { |
| * int a = 0; |
| * try { |
| * a += 1; |
| * } finally { |
| * try { |
| * a += 2; |
| * } finally { |
| * a += 3; |
| * } |
| * } |
| * } |
| * </pre> |
| */ |
| public void testSimpleNestedFinally() { |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| Label L5 = new Label(); |
| |
| setCurrent(jsr); |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L0: Body of try block: |
| LABEL(L0); |
| IINC(1, 1); |
| JSR(L3); |
| GOTO(L1); |
| |
| // L2: First exception handler: |
| LABEL(L2); |
| JSR(L3); |
| ATHROW(); |
| |
| // L3: First subroutine: |
| LABEL(L3); |
| ASTORE(2); |
| IINC(1, 2); |
| JSR(L4); |
| RET(2); |
| |
| // L5: Second exception handler: |
| LABEL(L5); |
| JSR(L4); |
| ATHROW(); |
| |
| // L4: Second subroutine: |
| LABEL(L4); |
| ASTORE(3); |
| IINC(1, 3); |
| RET(3); |
| |
| // L1: On normal exit, try block jumps here: |
| LABEL(L1); |
| RETURN(); |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L3, L5, L5); |
| |
| END(2, 6); |
| } |
| |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3_1a = new Label(); |
| Label L3_1b = new Label(); |
| Label L3_2a = new Label(); |
| Label L3_2b = new Label(); |
| Label L4_1a = new Label(); |
| Label L4_1b = new Label(); |
| Label L4_2a = new Label(); |
| Label L4_2b = new Label(); |
| Label L4_3a = new Label(); |
| Label L4_3b = new Label(); |
| Label L4_4a = new Label(); |
| Label L4_4b = new Label(); |
| Label L5_1 = new Label(); |
| Label L5_2 = new Label(); |
| |
| setCurrent(exp); |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L0: Body of try block: |
| LABEL(L0); |
| IINC(1, 1); |
| ACONST_NULL(); |
| GOTO(L3_1a); |
| LABEL(L3_1b); // L3_1b |
| GOTO(L1); |
| |
| // L2: First exception handler: |
| LABEL(L2); |
| ACONST_NULL(); |
| GOTO(L3_2a); |
| LABEL(L3_2b); // L3_2b |
| ATHROW(); |
| |
| // L1: On normal exit, try block jumps here: |
| LABEL(L1); |
| RETURN(); |
| |
| // L3_1a: First instantiation of first subroutine: |
| LABEL(L3_1a); |
| ASTORE(2); |
| IINC(1, 2); |
| ACONST_NULL(); |
| GOTO(L4_1a); |
| LABEL(L4_1b); // L4_1b |
| GOTO(L3_1b); |
| LABEL(L5_1); // L5_1 |
| ACONST_NULL(); |
| GOTO(L4_2a); |
| LABEL(L4_2b); // L4_2b |
| ATHROW(); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L3_2a: Second instantiation of first subroutine: |
| LABEL(L3_2a); |
| ASTORE(2); |
| IINC(1, 2); |
| ACONST_NULL(); |
| GOTO(L4_3a); |
| LABEL(L4_3b); // L4_3b |
| GOTO(L3_2b); |
| LABEL(L5_2); // L5_2 |
| ACONST_NULL(); |
| GOTO(L4_4a); |
| LABEL(L4_4b); // L4_4b |
| ATHROW(); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L4_1a: First instantiation of second subroutine: |
| LABEL(L4_1a); |
| ASTORE(3); |
| IINC(1, 3); |
| GOTO(L4_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L4_2a: Second instantiation of second subroutine: |
| LABEL(L4_2a); |
| ASTORE(3); |
| IINC(1, 3); |
| GOTO(L4_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L4_3a: Third instantiation of second subroutine: |
| LABEL(L4_3a); |
| ASTORE(3); |
| IINC(1, 3); |
| GOTO(L4_3b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L4_4a: Fourth instantiation of second subroutine: |
| LABEL(L4_4a); |
| ASTORE(3); |
| IINC(1, 3); |
| GOTO(L4_4b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L3_1a, L5_1, L5_1); |
| TRYCATCH(L3_2a, L5_2, L5_2); |
| |
| END(2, 6); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * This tests a subroutine which has no ret statement, but ends in a |
| * "return" instead. |
| * |
| * We structure this as a try/finally with a break in the finally. Because |
| * the while loop is infinite, it's clear from the byte code that the only |
| * path which reaches the RETURN instruction is through the subroutine. |
| * |
| * <pre> |
| * public void a1() { |
| * int a = 0; |
| * while (true) { |
| * try { |
| * a += 1; |
| * } finally { |
| * a += 2; |
| * break; |
| * } |
| * } |
| * } |
| * </pre> |
| */ |
| public void testSubroutineWithNoRet() { |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L0: while loop header/try block |
| LABEL(L0); |
| IINC(1, 1); |
| JSR(L1); |
| GOTO(L2); |
| |
| // L3: implicit catch block |
| LABEL(L3); |
| ASTORE(2); |
| JSR(L1); |
| ALOAD(2); |
| ATHROW(); |
| |
| // L1: subroutine ... |
| LABEL(L1); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4); // ...not that it does not return! |
| |
| // L2: end of the loop... goes back to the top! |
| LABEL(L2); |
| GOTO(L0); |
| |
| // L4: |
| LABEL(L4); |
| RETURN(); |
| |
| TRYCATCH(L0, L3, L3); |
| |
| END(1, 4); |
| } |
| |
| { |
| Label L0 = new Label(); |
| Label L1_1a = new Label(); |
| Label L1_1b = new Label(); |
| Label L1_2a = new Label(); |
| Label L1_2b = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4_1 = new Label(); |
| Label L4_2 = new Label(); |
| |
| setCurrent(exp); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L0: while loop header/try block |
| LABEL(L0); |
| IINC(1, 1); |
| ACONST_NULL(); |
| GOTO(L1_1a); |
| LABEL(L1_1b); // L1_1b |
| GOTO(L2); |
| |
| // L3: implicit catch block |
| LABEL(L3); |
| ASTORE(2); |
| ACONST_NULL(); |
| GOTO(L1_2a); |
| LABEL(L1_2b); // L1_2b |
| ALOAD(2); |
| ATHROW(); |
| |
| // L2: end of the loop... goes back to the top! |
| LABEL(L2); |
| GOTO(L0); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L1_1a: first instantiation of subroutine ... |
| LABEL(L1_1a); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4_1); // ...not that it does not return! |
| LABEL(L4_1); |
| RETURN(); |
| |
| // L1_2a: second instantiation of subroutine ... |
| LABEL(L1_2a); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4_2); // ...not that it does not return! |
| LABEL(L4_2); |
| RETURN(); |
| |
| TRYCATCH(L0, L3, L3); |
| |
| END(1, 4); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * This tests a subroutine which has no ret statement, but ends in a |
| * "return" instead. |
| * |
| * <pre> |
| * JSR L0 |
| * L0: |
| * ASTORE 0 |
| * RETURN |
| * </pre> |
| */ |
| public void testSubroutineWithNoRet2() { |
| { |
| Label L0 = new Label(); |
| |
| setCurrent(jsr); |
| JSR(L0); |
| LABEL(L0); |
| ASTORE(0); |
| RETURN(); |
| END(1, 1); |
| } |
| |
| { |
| Label L0_1a = new Label(); |
| Label L0_1b = new Label(); |
| |
| setCurrent(exp); |
| |
| ACONST_NULL(); |
| GOTO(L0_1a); |
| LABEL(L0_1b); |
| |
| // L0_1a: First instantiation of subroutine: |
| LABEL(L0_1a); |
| ASTORE(0); |
| RETURN(); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| END(1, 1); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * This tests a subroutine which has no ret statement, but instead exits |
| * implicitely by branching to code which is not part of the subroutine. |
| * (Sadly, this is legal) |
| * |
| * We structure this as a try/finally in a loop with a break in the finally. |
| * The loop is not trivially infinite, so the RETURN statement is reachable |
| * both from the JSR subroutine and from the main entry point. |
| * |
| * <pre> |
| * public void a1() { |
| * int a = 0; |
| * while (null == null) { |
| * try { |
| * a += 1; |
| * } finally { |
| * a += 2; |
| * break; |
| * } |
| * } |
| * } |
| * </pre> |
| */ |
| public void testImplicitExit() { |
| { |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| Label L5 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L5: while loop header |
| LABEL(L5); |
| ACONST_NULL(); |
| IFNONNULL(L4); |
| |
| // L0: try block |
| LABEL(L0); |
| IINC(1, 1); |
| JSR(L1); |
| GOTO(L2); |
| |
| // L3: implicit catch block |
| LABEL(L3); |
| ASTORE(2); |
| JSR(L1); |
| ALOAD(2); |
| ATHROW(); |
| |
| // L1: subroutine ... |
| LABEL(L1); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4); // ...not that it does not return! |
| |
| // L2: end of the loop... goes back to the top! |
| LABEL(L2); |
| GOTO(L0); |
| |
| // L4: |
| LABEL(L4); |
| RETURN(); |
| |
| TRYCATCH(L0, L3, L3); |
| |
| END(1, 4); |
| } |
| |
| { |
| Label L0 = new Label(); |
| Label L1_1a = new Label(); |
| Label L1_1b = new Label(); |
| Label L1_2a = new Label(); |
| Label L1_2b = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| Label L5 = new Label(); |
| |
| setCurrent(exp); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // L5: while loop header |
| LABEL(L5); |
| ACONST_NULL(); |
| IFNONNULL(L4); |
| |
| // L0: while loop header/try block |
| LABEL(L0); |
| IINC(1, 1); |
| ACONST_NULL(); |
| GOTO(L1_1a); |
| LABEL(L1_1b); // L1_1b |
| GOTO(L2); |
| |
| // L3: implicit catch block |
| LABEL(L3); |
| ASTORE(2); |
| ACONST_NULL(); |
| GOTO(L1_2a); |
| LABEL(L1_2b); // L1_2b |
| ALOAD(2); |
| ATHROW(); |
| |
| // L2: end of the loop... goes back to the top! |
| LABEL(L2); |
| GOTO(L0); |
| |
| // L4: exit, not part of subroutine |
| // Note that the two subroutine instantiations branch here |
| LABEL(L4); |
| RETURN(); |
| |
| // L1_1a: first instantiation of subroutine ... |
| LABEL(L1_1a); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4); // ...note that it does not return! |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L1_2a: second instantiation of subroutine ... |
| LABEL(L1_2a); |
| ASTORE(3); |
| IINC(1, 2); |
| GOTO(L4); // ...note that it does not return! |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| TRYCATCH(L0, L3, L3); |
| |
| END(1, 4); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * Tests a nested try/finally with implicit exit from one subroutine to the |
| * other subroutine. Equivalent to the following java code: |
| * |
| * <pre> |
| * void m(boolean b) { |
| * try { |
| * return; |
| * } finally { |
| * while (b) { |
| * try { |
| * return; |
| * } finally { |
| * // NOTE --- this break avoids the second return above (weird) |
| * if (b) |
| * break; |
| * } |
| * } |
| * } |
| * } |
| * </pre> |
| * |
| * This example is from the paper, "Subroutine Inlining and Bytecode |
| * Abstraction to Simplify Static and Dynamic Analysis" by Cyrille Artho and |
| * Armin Biere. |
| */ |
| public void testImplicitExitToAnotherSubroutine() { |
| { |
| Label T1 = new Label(); |
| Label C1 = new Label(); |
| Label S1 = new Label(); |
| Label L = new Label(); |
| Label C2 = new Label(); |
| Label S2 = new Label(); |
| Label W = new Label(); |
| Label X = new Label(); |
| |
| // variable numbers: |
| int b = 1; |
| int e1 = 2; |
| int e2 = 3; |
| int r1 = 4; |
| int r2 = 5; |
| |
| setCurrent(jsr); |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // T1: first try: |
| LABEL(T1); |
| JSR(S1); |
| RETURN(); |
| |
| // C1: exception handler for first try |
| LABEL(C1); |
| ASTORE(e1); |
| JSR(S1); |
| ALOAD(e1); |
| ATHROW(); |
| |
| // S1: first finally handler |
| LABEL(S1); |
| ASTORE(r1); |
| GOTO(W); |
| |
| // L: body of while loop, also second try |
| LABEL(L); |
| JSR(S2); |
| RETURN(); |
| |
| // C2: exception handler for second try |
| LABEL(C2); |
| ASTORE(e2); |
| JSR(S2); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // S2: second finally handler |
| LABEL(S2); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X); |
| RET(r2); |
| |
| // W: test for the while loop |
| LABEL(W); |
| ILOAD(b); |
| IFNE(L); // falls through to X |
| |
| // X: exit from finally{} block |
| LABEL(X); |
| RET(r1); |
| |
| TRYCATCH(T1, C1, C1); |
| TRYCATCH(L, C2, C2); |
| |
| END(1, 6); |
| } |
| |
| { |
| Label T1 = new Label(); |
| Label C1 = new Label(); |
| Label S1_1a = new Label(); |
| Label S1_1b = new Label(); |
| Label S1_2a = new Label(); |
| Label S1_2b = new Label(); |
| Label L_1 = new Label(); |
| Label L_2 = new Label(); |
| Label C2_1 = new Label(); |
| Label C2_2 = new Label(); |
| Label S2_1_1a = new Label(); |
| Label S2_1_1b = new Label(); |
| Label S2_1_2a = new Label(); |
| Label S2_1_2b = new Label(); |
| Label S2_2_1a = new Label(); |
| Label S2_2_1b = new Label(); |
| Label S2_2_2a = new Label(); |
| Label S2_2_2b = new Label(); |
| Label W_1 = new Label(); |
| Label W_2 = new Label(); |
| Label X_1 = new Label(); |
| Label X_2 = new Label(); |
| |
| // variable numbers: |
| int b = 1; |
| int e1 = 2; |
| int e2 = 3; |
| int r1 = 4; |
| int r2 = 5; |
| |
| setCurrent(exp); |
| |
| // --- Main Subroutine --- |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // T1: first try: |
| LABEL(T1); |
| ACONST_NULL(); |
| GOTO(S1_1a); |
| LABEL(S1_1b); |
| RETURN(); |
| |
| // C1: exception handler for first try |
| LABEL(C1); |
| ASTORE(e1); |
| ACONST_NULL(); |
| GOTO(S1_2a); |
| LABEL(S1_2b); |
| ALOAD(e1); |
| ATHROW(); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // --- First instantiation of first subroutine --- |
| |
| // S1: first finally handler |
| LABEL(S1_1a); |
| ASTORE(r1); |
| GOTO(W_1); |
| |
| // L_1: body of while loop, also second try |
| LABEL(L_1); |
| ACONST_NULL(); |
| GOTO(S2_1_1a); |
| LABEL(S2_1_1b); |
| RETURN(); |
| |
| // C2_1: exception handler for second try |
| LABEL(C2_1); |
| ASTORE(e2); |
| ACONST_NULL(); |
| GOTO(S2_1_2a); |
| LABEL(S2_1_2b); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // W_1: test for the while loop |
| LABEL(W_1); |
| ILOAD(b); |
| IFNE(L_1); // falls through to X_1 |
| |
| // X_1: exit from finally{} block |
| LABEL(X_1); |
| GOTO(S1_1b); |
| |
| // --- Second instantiation of first subroutine --- |
| |
| // S1: first finally handler |
| LABEL(S1_2a); |
| ASTORE(r1); |
| GOTO(W_2); |
| |
| // L_2: body of while loop, also second try |
| LABEL(L_2); |
| ACONST_NULL(); |
| GOTO(S2_2_1a); |
| LABEL(S2_2_1b); |
| RETURN(); |
| |
| // C2_2: exception handler for second try |
| LABEL(C2_2); |
| ASTORE(e2); |
| ACONST_NULL(); |
| GOTO(S2_2_2a); |
| LABEL(S2_2_2b); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // W_2: test for the while loop |
| LABEL(W_2); |
| ILOAD(b); |
| IFNE(L_2); // falls through to X_2 |
| |
| // X_2: exit from finally{} block |
| LABEL(X_2); |
| GOTO(S1_2b); |
| |
| // --- Second subroutine's 4 instantiations --- |
| |
| // S2_1_1a: |
| LABEL(S2_1_1a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_1); |
| GOTO(S2_1_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // S2_1_2a: |
| LABEL(S2_1_2a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_1); |
| GOTO(S2_1_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // S2_2_1a: |
| LABEL(S2_2_1a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_2); |
| GOTO(S2_2_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // S2_2_2a: |
| LABEL(S2_2_2a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_2); |
| GOTO(S2_2_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| TRYCATCH(T1, C1, C1); |
| TRYCATCH(L_1, C2_1, C2_1); // duplicated try/finally for each... |
| TRYCATCH(L_2, C2_2, C2_2); // ...instantiation of first sub |
| |
| END(1, 6); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * This tests two subroutines, neither of which exit. Instead, they both |
| * branch to a common set of code which returns from the method. This code |
| * is not reachable except through these subroutines, and since they do not |
| * invoke each other, it must be copied into both of them. |
| * |
| * I don't believe this can be represented in Java. |
| */ |
| public void testCommonCodeWhichMustBeDuplicated() { |
| { |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // Invoke the two subroutines, each twice: |
| JSR(L1); |
| JSR(L1); |
| JSR(L2); |
| JSR(L2); |
| RETURN(); |
| |
| // L1: subroutine 1 |
| LABEL(L1); |
| IINC(1, 1); |
| GOTO(L3); // ...note that it does not return! |
| |
| // L2: subroutine 2 |
| LABEL(L2); |
| IINC(1, 2); |
| GOTO(L3); // ...note that it does not return! |
| |
| // L3: common code to both subroutines: exit method |
| LABEL(L3); |
| RETURN(); |
| |
| END(1, 2); |
| } |
| |
| { |
| Label L1_1a = new Label(); |
| Label L1_1b = new Label(); |
| Label L1_2a = new Label(); |
| Label L1_2b = new Label(); |
| Label L2_1a = new Label(); |
| Label L2_1b = new Label(); |
| Label L2_2a = new Label(); |
| Label L2_2b = new Label(); |
| Label L3_1 = new Label(); |
| Label L3_2 = new Label(); |
| Label L3_3 = new Label(); |
| Label L3_4 = new Label(); |
| |
| setCurrent(exp); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // Invoke the two subroutines, each twice: |
| ACONST_NULL(); |
| GOTO(L1_1a); |
| LABEL(L1_1b); |
| ACONST_NULL(); |
| GOTO(L1_2a); |
| LABEL(L1_2b); |
| ACONST_NULL(); |
| GOTO(L2_1a); |
| LABEL(L2_1b); |
| ACONST_NULL(); |
| GOTO(L2_2a); |
| LABEL(L2_2b); |
| RETURN(); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L1_1a: instantiation 1 of subroutine 1 |
| LABEL(L1_1a); |
| IINC(1, 1); |
| GOTO(L3_1); // ...note that it does not return! |
| LABEL(L3_1); |
| RETURN(); |
| |
| // L1_2a: instantiation 2 of subroutine 1 |
| LABEL(L1_2a); |
| IINC(1, 1); |
| GOTO(L3_2); // ...note that it does not return! |
| LABEL(L3_2); |
| RETURN(); |
| |
| // L2_1a: instantiation 1 of subroutine 2 |
| LABEL(L2_1a); |
| IINC(1, 2); |
| GOTO(L3_3); // ...note that it does not return! |
| LABEL(L3_3); |
| RETURN(); |
| |
| // L2_2a: instantiation 2 of subroutine 2 |
| LABEL(L2_2a); |
| IINC(1, 2); |
| GOTO(L3_4); // ...note that it does not return! |
| LABEL(L3_4); |
| RETURN(); |
| |
| END(1, 2); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * This tests a simple subroutine where the control flow jumps back and |
| * forth between the subroutine and the caller. |
| * |
| * This would not normally be produced by a java compiler. |
| */ |
| public void testInterleavedCode() { |
| { |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(jsr); |
| ICONST_0(); |
| ISTORE(1); |
| |
| // Invoke the subroutine, each twice: |
| JSR(L1); |
| GOTO(L2); |
| |
| // L1: subroutine 1 |
| LABEL(L1); |
| ASTORE(2); |
| IINC(1, 1); |
| GOTO(L3); |
| |
| // L2: second part of main subroutine |
| LABEL(L2); |
| IINC(1, 2); |
| GOTO(L4); |
| |
| // L3: second part of subroutine 1 |
| LABEL(L3); |
| IINC(1, 4); |
| RET(2); |
| |
| // L4: third part of main subroutine |
| LABEL(L4); |
| JSR(L1); |
| RETURN(); |
| |
| END(1, 3); |
| } |
| |
| { |
| Label L1_1a = new Label(); |
| Label L1_1b = new Label(); |
| Label L1_2a = new Label(); |
| Label L1_2b = new Label(); |
| Label L2 = new Label(); |
| Label L3_1 = new Label(); |
| Label L3_2 = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(exp); |
| |
| // Main routine: |
| ICONST_0(); |
| ISTORE(1); |
| ACONST_NULL(); |
| GOTO(L1_1a); |
| LABEL(L1_1b); |
| GOTO(L2); |
| LABEL(L2); |
| IINC(1, 2); |
| GOTO(L4); |
| LABEL(L4); |
| ACONST_NULL(); |
| GOTO(L1_2a); |
| LABEL(L1_2b); |
| RETURN(); |
| |
| // L1_1: instantiation #1 |
| LABEL(L1_1a); |
| ASTORE(2); |
| IINC(1, 1); |
| GOTO(L3_1); |
| LABEL(L3_1); |
| IINC(1, 4); |
| GOTO(L1_1b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| // L1_2: instantiation #2 |
| LABEL(L1_2a); |
| ASTORE(2); |
| IINC(1, 1); |
| GOTO(L3_2); |
| LABEL(L3_2); |
| IINC(1, 4); |
| GOTO(L1_2b); |
| LABEL(new Label()); // extra label emitted due to impl quirks |
| |
| END(1, 3); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * Tests a nested try/finally with implicit exit from one subroutine to the |
| * other subroutine, and with a surrounding try/catch thrown in the mix. |
| * Equivalent to the following java code: |
| * |
| * <pre> |
| * void m(int b) { |
| * try { |
| * try { |
| * return; |
| * } finally { |
| * while (b) { |
| * try { |
| * return; |
| * } finally { |
| * // NOTE --- this break avoids the second return above |
| * // (weird) |
| * if (b) |
| * break; |
| * } |
| * } |
| * } |
| * } catch (Exception e) { |
| * b += 3; |
| * return; |
| * } |
| * } |
| * </pre> |
| */ |
| public void testImplicitExitInTryCatch() { |
| { |
| Label T1 = new Label(); |
| Label C1 = new Label(); |
| Label S1 = new Label(); |
| Label L = new Label(); |
| Label C2 = new Label(); |
| Label S2 = new Label(); |
| Label W = new Label(); |
| Label X = new Label(); |
| Label OT = new Label(); |
| Label OC = new Label(); |
| |
| // variable numbers: |
| int b = 1; |
| int e1 = 2; |
| int e2 = 3; |
| int r1 = 4; |
| int r2 = 5; |
| |
| setCurrent(jsr); |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // OT: outermost try |
| LABEL(OT); |
| |
| // T1: first try: |
| LABEL(T1); |
| JSR(S1); |
| RETURN(); |
| |
| // C1: exception handler for first try |
| LABEL(C1); |
| ASTORE(e1); |
| JSR(S1); |
| ALOAD(e1); |
| ATHROW(); |
| |
| // S1: first finally handler |
| LABEL(S1); |
| ASTORE(r1); |
| GOTO(W); |
| |
| // L: body of while loop, also second try |
| LABEL(L); |
| JSR(S2); |
| RETURN(); |
| |
| // C2: exception handler for second try |
| LABEL(C2); |
| ASTORE(e2); |
| JSR(S2); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // S2: second finally handler |
| LABEL(S2); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X); |
| RET(r2); |
| |
| // W: test for the while loop |
| LABEL(W); |
| ILOAD(b); |
| IFNE(L); // falls through to X |
| |
| // X: exit from finally{} block |
| LABEL(X); |
| RET(r1); |
| |
| // OC: outermost catch |
| LABEL(OC); |
| IINC(b, 3); |
| RETURN(); |
| |
| TRYCATCH(T1, C1, C1); |
| TRYCATCH(L, C2, C2); |
| TRYCATCH(OT, OC, OC); |
| |
| END(1, 6); |
| } |
| |
| { |
| Label T1 = new Label(); |
| Label C1 = new Label(); |
| Label S1_1a = new Label(); |
| Label S1_1b = new Label(); |
| Label S1_2a = new Label(); |
| Label S1_2b = new Label(); |
| Label L_1 = new Label(); |
| Label L_2 = new Label(); |
| Label C2_1 = new Label(); |
| Label C2_2 = new Label(); |
| Label S2_1_1a = new Label(); |
| Label S2_1_1b = new Label(); |
| Label S2_1_2a = new Label(); |
| Label S2_1_2b = new Label(); |
| Label S2_2_1a = new Label(); |
| Label S2_2_1b = new Label(); |
| Label S2_2_2a = new Label(); |
| Label S2_2_2b = new Label(); |
| Label W_1 = new Label(); |
| Label W_2 = new Label(); |
| Label X_1 = new Label(); |
| Label X_2 = new Label(); |
| Label OT_1 = S1_1a; |
| Label OT_2 = S1_2a; |
| Label OT_1_1 = S2_1_1a; |
| Label OT_1_2 = S2_1_2a; |
| Label OT_2_1 = S2_2_1a; |
| Label OT_2_2 = S2_2_2a; |
| Label OC = new Label(); |
| Label OC_1 = new Label(); |
| Label OC_2 = new Label(); |
| Label OC_1_1 = new Label(); |
| Label OC_1_2 = new Label(); |
| Label OC_2_1 = new Label(); |
| Label OC_2_2 = new Label(); |
| |
| // variable numbers: |
| int b = 1; |
| int e1 = 2; |
| int e2 = 3; |
| int r1 = 4; |
| int r2 = 5; |
| |
| setCurrent(exp); |
| |
| // --- Main Subroutine --- |
| |
| ICONST_0(); |
| ISTORE(1); |
| |
| // T1: outermost try / first try: |
| LABEL(T1); |
| ACONST_NULL(); |
| GOTO(S1_1a); |
| LABEL(S1_1b); |
| RETURN(); |
| |
| // C1: exception handler for first try |
| LABEL(C1); |
| ASTORE(e1); |
| ACONST_NULL(); |
| GOTO(S1_2a); |
| LABEL(S1_2b); |
| ALOAD(e1); |
| ATHROW(); |
| |
| // OC: Outermost catch |
| LABEL(OC); |
| IINC(b, 3); |
| RETURN(); |
| |
| // --- First instantiation of first subroutine --- |
| |
| // S1: first finally handler |
| LABEL(S1_1a); |
| ASTORE(r1); |
| GOTO(W_1); |
| |
| // L_1: body of while loop, also second try |
| LABEL(L_1); |
| ACONST_NULL(); |
| GOTO(S2_1_1a); |
| LABEL(S2_1_1b); |
| RETURN(); |
| |
| // C2_1: exception handler for second try |
| LABEL(C2_1); |
| ASTORE(e2); |
| ACONST_NULL(); |
| GOTO(S2_1_2a); |
| LABEL(S2_1_2b); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // W_1: test for the while loop |
| LABEL(W_1); |
| ILOAD(b); |
| IFNE(L_1); // falls through to X_1 |
| |
| // X_1: exit from finally{} block |
| LABEL(X_1); |
| GOTO(S1_1b); |
| |
| LABEL(OC_1); |
| |
| // --- Second instantiation of first subroutine --- |
| |
| // S1: first finally handler |
| LABEL(S1_2a); |
| ASTORE(r1); |
| GOTO(W_2); |
| |
| // L_2: body of while loop, also second try |
| LABEL(L_2); |
| ACONST_NULL(); |
| GOTO(S2_2_1a); |
| LABEL(S2_2_1b); |
| RETURN(); |
| |
| // C2_2: exception handler for second try |
| LABEL(C2_2); |
| ASTORE(e2); |
| ACONST_NULL(); |
| GOTO(S2_2_2a); |
| LABEL(S2_2_2b); |
| ALOAD(e2); |
| ATHROW(); |
| |
| // W_2: test for the while loop |
| LABEL(W_2); |
| ILOAD(b); |
| IFNE(L_2); // falls through to X_2 |
| |
| // X_2: exit from finally{} block |
| LABEL(X_2); |
| GOTO(S1_2b); |
| |
| LABEL(OC_2); |
| |
| // --- Second subroutine's 4 instantiations --- |
| |
| // S2_1_1a: |
| LABEL(S2_1_1a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_1); |
| GOTO(S2_1_1b); |
| LABEL(OC_1_1); |
| |
| // S2_1_2a: |
| LABEL(S2_1_2a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_1); |
| GOTO(S2_1_2b); |
| LABEL(OC_1_2); |
| |
| // S2_2_1a: |
| LABEL(S2_2_1a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_2); |
| GOTO(S2_2_1b); |
| LABEL(OC_2_1); |
| |
| // S2_2_2a: |
| LABEL(S2_2_2a); |
| ASTORE(r2); |
| ILOAD(b); |
| IFNE(X_2); |
| GOTO(S2_2_2b); |
| LABEL(OC_2_2); |
| |
| // main subroutine handlers: |
| TRYCATCH(T1, C1, C1); |
| TRYCATCH(T1, OC, OC); |
| |
| // first instance of first sub try/catch handlers: |
| TRYCATCH(L_1, C2_1, C2_1); |
| TRYCATCH(OT_1, OC_1, OC); // note: reuses handler code from main |
| // sub |
| |
| // second instance of first sub try/catch handlers: |
| TRYCATCH(L_2, C2_2, C2_2); |
| TRYCATCH(OT_2, OC_2, OC); |
| |
| // all 4 instances of second sub: |
| TRYCATCH(OT_1_1, OC_1_1, OC); |
| TRYCATCH(OT_1_2, OC_1_2, OC); |
| TRYCATCH(OT_2_1, OC_2_1, OC); |
| TRYCATCH(OT_2_2, OC_2_2, OC); |
| |
| END(1, 6); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| /** |
| * Tests a method which has line numbers and local variable declarations. |
| * |
| * <pre> |
| * public void a() { |
| * 1 int a = 0; |
| * 2 try { |
| * 3 a++; |
| * 4 } finally { |
| * 5 a--; |
| * 6 } |
| * } |
| * LV "a" from 1 to 6 |
| * </pre> |
| */ |
| public void testBasicLineNumberAndLocalVars() { |
| { |
| Label LM1 = new Label(); |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3 = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(jsr); |
| LABEL(LM1); |
| LINE(1, LM1); |
| ICONST_0(); |
| ISTORE(1); |
| |
| /* L0: body of try block */ |
| LABEL(L0); |
| LINE(3, L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| /* L2: exception handler */ |
| LABEL(L2); |
| ASTORE(3); |
| JSR(L3); |
| ALOAD(3); |
| ATHROW(); |
| |
| /* L3: subroutine */ |
| LABEL(L3); |
| LINE(5, L3); |
| ASTORE(2); |
| IINC(1, -1); |
| RET(2); |
| |
| /* L1: non-exceptional exit from try block */ |
| LABEL(L1); |
| JSR(L3); |
| LABEL(L4); // L4 |
| RETURN(); |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L4, L2); |
| LOCALVAR("a", "I", 1, LM1, L4); |
| |
| END(1, 4); |
| } |
| |
| { |
| Label LM1 = new Label(); |
| Label L0 = new Label(); |
| Label L1 = new Label(); |
| Label L2 = new Label(); |
| Label L3_1a = new Label(); |
| Label L3_1b = new Label(); |
| Label L3_1c = new Label(); |
| Label L3_2a = new Label(); |
| Label L3_2b = new Label(); |
| Label L3_2c = new Label(); |
| Label L4 = new Label(); |
| |
| setCurrent(exp); |
| LABEL(LM1); |
| LINE(1, LM1); |
| ICONST_0(); |
| ISTORE(1); |
| // L0: try/catch block |
| LABEL(L0); |
| LINE(3, L0); |
| IINC(1, 1); |
| GOTO(L1); |
| |
| // L2: Exception handler: |
| LABEL(L2); |
| ASTORE(3); |
| ACONST_NULL(); |
| GOTO(L3_1a); |
| LABEL(L3_1b); // L3_1b; |
| ALOAD(3); |
| ATHROW(); |
| |
| // L1: On non-exceptional exit, try block leads here: |
| LABEL(L1); |
| ACONST_NULL(); |
| GOTO(L3_2a); |
| LABEL(L3_2b); // L3_2b |
| LABEL(L4); // L4 |
| RETURN(); |
| |
| // L3_1a: First instantiation of subroutine: |
| LABEL(L3_1a); |
| LINE(5, L3_1a); |
| ASTORE(2); |
| IINC(1, -1); |
| GOTO(L3_1b); |
| LABEL(L3_1c); |
| |
| // L3_2a: Second instantiation of subroutine: |
| LABEL(L3_2a); |
| LINE(5, L3_2a); |
| ASTORE(2); |
| IINC(1, -1); |
| GOTO(L3_2b); |
| LABEL(L3_2c); |
| |
| TRYCATCH(L0, L2, L2); |
| TRYCATCH(L1, L4, L2); |
| LOCALVAR("a", "I", 1, LM1, L4); |
| LOCALVAR("a", "I", 1, L3_1a, L3_1c); |
| LOCALVAR("a", "I", 1, L3_2a, L3_2c); |
| |
| END(1, 4); |
| } |
| |
| assertEquals(exp, jsr); |
| } |
| |
| public void assertEquals(final MethodNode exp, final MethodNode actual) { |
| String textexp = getText(exp); |
| String textact = getText(actual); |
| System.err.println("Expected=" + textexp); |
| System.err.println("Actual=" + textact); |
| assertEquals(textexp, textact); |
| } |
| |
| private String getText(final MethodNode mn) { |
| Textifier tv = new Textifier(); |
| TraceMethodVisitor tmv = new TraceMethodVisitor(tv); |
| mn.accept(tmv); |
| |
| StringBuffer sb = new StringBuffer(); |
| for (int i = 0; i < tv.text.size(); i++) { |
| sb.append(tv.text.get(i)); |
| } |
| return sb.toString(); |
| } |
| } |
