diff options
Diffstat (limited to 'asm-test/src/resources/java/jdk5/AllInstructions.java')
| -rwxr-xr-x | asm-test/src/resources/java/jdk5/AllInstructions.java | 288 |
1 files changed, 288 insertions, 0 deletions
diff --git a/asm-test/src/resources/java/jdk5/AllInstructions.java b/asm-test/src/resources/java/jdk5/AllInstructions.java new file mode 100755 index 00000000..3137ee16 --- /dev/null +++ b/asm-test/src/resources/java/jdk5/AllInstructions.java @@ -0,0 +1,288 @@ +// ASM: a very small and fast Java bytecode manipulation framework +// 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 jdk5; + +/** + * Class which, compiled with the JDK 1.5.0, produces the new JVM instructions from that version + * (compared to JDK 1.3.0). Also contain all the other instructions that can be used in JDK 1.5 + * classes (which excludes jsr and ret), so that ASM classes which don't support jsr or ret (and + * therefore can't be tested with jdk3.AllInstructions) can still be tested on all instructions. + * Must be compiled with "javac -g". + */ +class AllInstructions { + private Class c; + private Class d; + private int f; + private long g; + private AllInstructions field; + private static AllInstructions staticField; + + AllInstructions() {} + + AllInstructions(int v0, float v1, long v2, double v3, Object v4) {} + + // New instruction in JDK 1.5. + public void ldcWithClassConstant() { + c = AllInstructions.class; + d = AllInstructions[].class; + } + + public static int intInstructions( + int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8) { + boolean b0 = v0 < -1; + boolean b1 = v1 > 1; + boolean b2 = v2 <= 2; + boolean b3 = v3 >= 3; + boolean b4 = v4 == 4; + boolean b5 = v5 != 5; + v0 = b0 ? (v6 + 5) : (v6 - 5); + v1 = b1 ? (v7 * 100) : (v7 / 100); + v2 = b2 ? (v8 % 10000) : (~v8); + v3 = b3 ? (v0 & 1000000) : (v0 | 1000000); + v4 = b4 ? (v1 ^ v2) : (v1 << v2); + v5 = b5 ? (v2 >> v3) : (v2 >>> v3); + v6 += 1; + v7 = v6 < 0 ? -v6 : v6; + v1 = v0 < 0 ? v1 : v2; + v2 = v1 > 0 ? v2 : v3; + v3 = v2 <= 0 ? v3 : v4; + v4 = v3 >= 0 ? v4 : v5; + v5 = v4 == 0 ? v5 : v6; + v6 = v5 != 0 ? v6 : v7; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + public static long longInstructions( + long v0, long v1, long v2, long v3, long v4, long v5, long v6, long v7, long v8) { + boolean b0 = v0 < -1L; + boolean b1 = v1 > 1L; + boolean b2 = v2 <= 2L; + boolean b3 = v3 >= 3L; + boolean b4 = v4 == 4L; + boolean b5 = v5 != 5L; + v0 = b0 ? (v6 + 5L) : (v6 - 5L); + v1 = b1 ? (v7 * 100L) : (v7 / 100L); + v2 = b2 ? (v8 % 10000L) : (~v8); + v3 = b3 ? (v0 & 1000000L) : (v0 | 1000000L); + v4 = b4 ? (v1 ^ v2) : (v1 << v2); + v5 = b5 ? (v2 >> v3) : (v2 >>> v3); + v6 += 1L; + v7 = v6 < 0L ? -v6 : v6; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + public static float floatInstructions( + float v0, float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8) { + boolean b0 = v0 < -1f; + boolean b1 = v1 > 1f; + boolean b2 = v2 <= 2f; + boolean b3 = v3 >= 3f; + boolean b4 = v4 == 4f; + boolean b5 = v5 != 5f; + v0 = b0 ? (v6 + 5f) : (v6 - 5f); + v1 = b1 ? (v7 * 100f) : (v7 / 100f); + v2 = b2 ? (v8 % 10000f) : v8; + v3 = b3 ? -v3 : v3; + v4 = b4 ? -v4 : v4; + v5 = b5 ? -v5 : v5; + v6 += 1f; + v7 = v6 < 0f ? -v6 : v6; + v8 = v7; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + public static double doubleInstructions( + double v0, + double v1, + double v2, + double v3, + double v4, + double v5, + double v6, + double v7, + double v8) { + boolean b0 = v0 < -1d; + boolean b1 = v1 > 1d; + boolean b2 = v2 <= 2d; + boolean b3 = v3 >= 3d; + boolean b4 = v4 == 4d; + boolean b5 = v5 != 5d; + v0 = b0 ? (v6 + 5d) : (v6 - 5d); + v1 = b1 ? (v7 * 100d) : (v7 / 100d); + v2 = b2 ? (v8 % 10000d) : v8; + v3 = b3 ? -v3 : v3; + v4 = b4 ? -v4 : v4; + v5 = b5 ? -v5 : v5; + v6 += 1d; + v7 = v6 < 0d ? -v6 : v6; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + public static double castInstructions(int v0, long v1, long v2) { + byte v3 = (byte) v0; + char v4 = (char) v1; + short v5 = (short) v2; + long v6 = (long) v3; + float v7 = (float) v4; + double v8 = (double) v5; + v1 = v6; + v2 = v1; + v6 = (long) v8; + return v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8; + } + + public static float castInstructions(float v0, double v1, double v2) { + byte v3 = (byte) v0; + char v4 = (char) v1; + short v5 = (short) v2; + long v6 = (long) v3; + float v7 = (float) v4; + double v8 = (double) v5; + v1 = v6; + v2 = v1; + v6 = (long) v7; + return (float) (v0 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8); + } + + public static Object objectInstructions(Object v0, Object v1, Object v2, Object v3, Object v4) { + boolean b0 = v0 == v1; + boolean b1 = v1 != v2; + boolean b2 = v2 == null; + boolean b3 = v3 != null; + boolean b4 = v4 instanceof String; + v0 = b0 ? null : v0; + v1 = b1 ? v1 : v0; + v2 = b2 ? v2 : v1; + v3 = b3 ? v3 : v2; + v4 = b4 ? new Integer(((String) v4).length()) : v3; + return v4; + } + + public static Object[] arrayInstructions( + byte[] v0, char[] v1, short[] v2, int[] v3, long[] v4, float[] v5, double[] v6, Object[] v7) { + v0[1] = v0[0]; + v1[1] = v1[0]; + v2[1] = v2[0]; + v3[1] = v3[0]; + v4[1] = v4[0]; + v5[1] = v5[0]; + v6[1] = v6[0]; + v7[1] = v7[0]; + Object[] v8 = new Object[v7.length]; + v8[0] = new int[4][8][16]; + return v8; + } + + public void fieldInstructions() { + AllInstructions c = field; + field = staticField; + staticField = c; + } + + public void methodInstructions(Runnable v0) { + AllInstructions c = new AllInstructions(); + c.fieldInstructions(); + monitorInstructions(c); + v0.run(); + } + + public static int lookupSwitchInstruction(int v0) { + switch (v0) { + case 1000: + return 1; + case 10000: + return 2; + case 100000: + return 3; + default: + return -1; + } + } + + public static int tableSwitchInstruction(int v0) { + switch (v0) { + case 0: + return 1; + case 1: + return 2; + case 2: + return 3; + default: + return -1; + } + } + + public static String monitorInstructions(Object v0) { + synchronized (v0) { + return v0.toString(); + } + } + + public int dupX1Instruction() { + return f++; + } + + public long dup2X1Instruction() { + return g++; + } + + public void dupX2Instruction(int[] v0, int[] v1) { + v0[0] = v1[0] = 0; + } + + public void dup2X2Instruction(long[] v0, long[] v1) { + v0[0] = v1[0] = 0; + } + + public void popInstructions() { + dupX1Instruction(); + dup2X1Instruction(); + } + + // With JDK1.5, this code no longer produces jsr or ret instructions. + public int jsrAndRetInstructions(int v0) throws Exception { + int u0 = v0 + 1; + try { + u0 = jsrAndRetInstructions(u0); + } catch (Throwable t) { + return -1; + } finally { + u0++; + } + return u0; + } + + public Object readNullArray() { + Object[] array = null; + try { + return array[0]; + } catch (NullPointerException e) { + return null; + } + } +} |