1 /*
2 * Copyright (c) 2009, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24
25 package org.graalvm.compiler.bytecode;
26
27 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.ASSOCIATIVE;
28 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.BRANCH;
29 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.COMMUTATIVE;
30 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.FALL_THROUGH;
31 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.FIELD_READ;
32 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.FIELD_WRITE;
33 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.INVOKE;
34 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.LOAD;
35 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.STOP;
36 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.STORE;
37 import static org.graalvm.compiler.bytecode.Bytecodes.Flags.TRAP;
38
39 import java.lang.reflect.Field;
40 import java.lang.reflect.Modifier;
41
42 /**
43 * Definitions of the standard Java bytecodes defined by
44 * <a href= "http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html"> Java
45 * Virtual Machine Specification</a>.
46 */
47 public class Bytecodes {
48
49 // @formatter:off
50 public static final int NOP = 0; // 0x00
51 public static final int ACONST_NULL = 1; // 0x01
52 public static final int ICONST_M1 = 2; // 0x02
53 public static final int ICONST_0 = 3; // 0x03
54 public static final int ICONST_1 = 4; // 0x04
55 public static final int ICONST_2 = 5; // 0x05
56 public static final int ICONST_3 = 6; // 0x06
57 public static final int ICONST_4 = 7; // 0x07
58 public static final int ICONST_5 = 8; // 0x08
59 public static final int LCONST_0 = 9; // 0x09
60 public static final int LCONST_1 = 10; // 0x0A
61 public static final int FCONST_0 = 11; // 0x0B
62 public static final int FCONST_1 = 12; // 0x0C
63 public static final int FCONST_2 = 13; // 0x0D
64 public static final int DCONST_0 = 14; // 0x0E
65 public static final int DCONST_1 = 15; // 0x0F
66 public static final int BIPUSH = 16; // 0x10
67 public static final int SIPUSH = 17; // 0x11
68 public static final int LDC = 18; // 0x12
69 public static final int LDC_W = 19; // 0x13
70 public static final int LDC2_W = 20; // 0x14
71 public static final int ILOAD = 21; // 0x15
72 public static final int LLOAD = 22; // 0x16
73 public static final int FLOAD = 23; // 0x17
74 public static final int DLOAD = 24; // 0x18
75 public static final int ALOAD = 25; // 0x19
76 public static final int ILOAD_0 = 26; // 0x1A
77 public static final int ILOAD_1 = 27; // 0x1B
78 public static final int ILOAD_2 = 28; // 0x1C
79 public static final int ILOAD_3 = 29; // 0x1D
80 public static final int LLOAD_0 = 30; // 0x1E
81 public static final int LLOAD_1 = 31; // 0x1F
82 public static final int LLOAD_2 = 32; // 0x20
83 public static final int LLOAD_3 = 33; // 0x21
84 public static final int FLOAD_0 = 34; // 0x22
85 public static final int FLOAD_1 = 35; // 0x23
86 public static final int FLOAD_2 = 36; // 0x24
87 public static final int FLOAD_3 = 37; // 0x25
88 public static final int DLOAD_0 = 38; // 0x26
89 public static final int DLOAD_1 = 39; // 0x27
90 public static final int DLOAD_2 = 40; // 0x28
91 public static final int DLOAD_3 = 41; // 0x29
92 public static final int ALOAD_0 = 42; // 0x2A
93 public static final int ALOAD_1 = 43; // 0x2B
94 public static final int ALOAD_2 = 44; // 0x2C
95 public static final int ALOAD_3 = 45; // 0x2D
96 public static final int IALOAD = 46; // 0x2E
97 public static final int LALOAD = 47; // 0x2F
98 public static final int FALOAD = 48; // 0x30
99 public static final int DALOAD = 49; // 0x31
100 public static final int AALOAD = 50; // 0x32
101 public static final int BALOAD = 51; // 0x33
102 public static final int CALOAD = 52; // 0x34
103 public static final int SALOAD = 53; // 0x35
104 public static final int ISTORE = 54; // 0x36
105 public static final int LSTORE = 55; // 0x37
106 public static final int FSTORE = 56; // 0x38
107 public static final int DSTORE = 57; // 0x39
108 public static final int ASTORE = 58; // 0x3A
109 public static final int ISTORE_0 = 59; // 0x3B
110 public static final int ISTORE_1 = 60; // 0x3C
111 public static final int ISTORE_2 = 61; // 0x3D
112 public static final int ISTORE_3 = 62; // 0x3E
113 public static final int LSTORE_0 = 63; // 0x3F
114 public static final int LSTORE_1 = 64; // 0x40
115 public static final int LSTORE_2 = 65; // 0x41
116 public static final int LSTORE_3 = 66; // 0x42
117 public static final int FSTORE_0 = 67; // 0x43
118 public static final int FSTORE_1 = 68; // 0x44
119 public static final int FSTORE_2 = 69; // 0x45
120 public static final int FSTORE_3 = 70; // 0x46
121 public static final int DSTORE_0 = 71; // 0x47
122 public static final int DSTORE_1 = 72; // 0x48
123 public static final int DSTORE_2 = 73; // 0x49
124 public static final int DSTORE_3 = 74; // 0x4A
125 public static final int ASTORE_0 = 75; // 0x4B
126 public static final int ASTORE_1 = 76; // 0x4C
127 public static final int ASTORE_2 = 77; // 0x4D
128 public static final int ASTORE_3 = 78; // 0x4E
129 public static final int IASTORE = 79; // 0x4F
130 public static final int LASTORE = 80; // 0x50
131 public static final int FASTORE = 81; // 0x51
132 public static final int DASTORE = 82; // 0x52
133 public static final int AASTORE = 83; // 0x53
134 public static final int BASTORE = 84; // 0x54
135 public static final int CASTORE = 85; // 0x55
136 public static final int SASTORE = 86; // 0x56
137 public static final int POP = 87; // 0x57
138 public static final int POP2 = 88; // 0x58
139 public static final int DUP = 89; // 0x59
140 public static final int DUP_X1 = 90; // 0x5A
141 public static final int DUP_X2 = 91; // 0x5B
142 public static final int DUP2 = 92; // 0x5C
143 public static final int DUP2_X1 = 93; // 0x5D
144 public static final int DUP2_X2 = 94; // 0x5E
145 public static final int SWAP = 95; // 0x5F
146 public static final int IADD = 96; // 0x60
147 public static final int LADD = 97; // 0x61
148 public static final int FADD = 98; // 0x62
149 public static final int DADD = 99; // 0x63
150 public static final int ISUB = 100; // 0x64
151 public static final int LSUB = 101; // 0x65
152 public static final int FSUB = 102; // 0x66
153 public static final int DSUB = 103; // 0x67
154 public static final int IMUL = 104; // 0x68
155 public static final int LMUL = 105; // 0x69
156 public static final int FMUL = 106; // 0x6A
157 public static final int DMUL = 107; // 0x6B
158 public static final int IDIV = 108; // 0x6C
159 public static final int LDIV = 109; // 0x6D
160 public static final int FDIV = 110; // 0x6E
161 public static final int DDIV = 111; // 0x6F
162 public static final int IREM = 112; // 0x70
163 public static final int LREM = 113; // 0x71
164 public static final int FREM = 114; // 0x72
165 public static final int DREM = 115; // 0x73
166 public static final int INEG = 116; // 0x74
167 public static final int LNEG = 117; // 0x75
168 public static final int FNEG = 118; // 0x76
169 public static final int DNEG = 119; // 0x77
170 public static final int ISHL = 120; // 0x78
171 public static final int LSHL = 121; // 0x79
172 public static final int ISHR = 122; // 0x7A
173 public static final int LSHR = 123; // 0x7B
174 public static final int IUSHR = 124; // 0x7C
175 public static final int LUSHR = 125; // 0x7D
176 public static final int IAND = 126; // 0x7E
177 public static final int LAND = 127; // 0x7F
178 public static final int IOR = 128; // 0x80
179 public static final int LOR = 129; // 0x81
180 public static final int IXOR = 130; // 0x82
181 public static final int LXOR = 131; // 0x83
182 public static final int IINC = 132; // 0x84
183 public static final int I2L = 133; // 0x85
184 public static final int I2F = 134; // 0x86
185 public static final int I2D = 135; // 0x87
186 public static final int L2I = 136; // 0x88
187 public static final int L2F = 137; // 0x89
188 public static final int L2D = 138; // 0x8A
189 public static final int F2I = 139; // 0x8B
190 public static final int F2L = 140; // 0x8C
191 public static final int F2D = 141; // 0x8D
192 public static final int D2I = 142; // 0x8E
193 public static final int D2L = 143; // 0x8F
194 public static final int D2F = 144; // 0x90
195 public static final int I2B = 145; // 0x91
196 public static final int I2C = 146; // 0x92
197 public static final int I2S = 147; // 0x93
198 public static final int LCMP = 148; // 0x94
199 public static final int FCMPL = 149; // 0x95
200 public static final int FCMPG = 150; // 0x96
201 public static final int DCMPL = 151; // 0x97
202 public static final int DCMPG = 152; // 0x98
203 public static final int IFEQ = 153; // 0x99
204 public static final int IFNE = 154; // 0x9A
205 public static final int IFLT = 155; // 0x9B
206 public static final int IFGE = 156; // 0x9C
207 public static final int IFGT = 157; // 0x9D
208 public static final int IFLE = 158; // 0x9E
209 public static final int IF_ICMPEQ = 159; // 0x9F
210 public static final int IF_ICMPNE = 160; // 0xA0
211 public static final int IF_ICMPLT = 161; // 0xA1
212 public static final int IF_ICMPGE = 162; // 0xA2
213 public static final int IF_ICMPGT = 163; // 0xA3
214 public static final int IF_ICMPLE = 164; // 0xA4
215 public static final int IF_ACMPEQ = 165; // 0xA5
216 public static final int IF_ACMPNE = 166; // 0xA6
217 public static final int GOTO = 167; // 0xA7
218 public static final int JSR = 168; // 0xA8
219 public static final int RET = 169; // 0xA9
220 public static final int TABLESWITCH = 170; // 0xAA
221 public static final int LOOKUPSWITCH = 171; // 0xAB
222 public static final int IRETURN = 172; // 0xAC
223 public static final int LRETURN = 173; // 0xAD
224 public static final int FRETURN = 174; // 0xAE
225 public static final int DRETURN = 175; // 0xAF
226 public static final int ARETURN = 176; // 0xB0
227 public static final int RETURN = 177; // 0xB1
228 public static final int GETSTATIC = 178; // 0xB2
229 public static final int PUTSTATIC = 179; // 0xB3
230 public static final int GETFIELD = 180; // 0xB4
231 public static final int PUTFIELD = 181; // 0xB5
232 public static final int INVOKEVIRTUAL = 182; // 0xB6
233 public static final int INVOKESPECIAL = 183; // 0xB7
234 public static final int INVOKESTATIC = 184; // 0xB8
235 public static final int INVOKEINTERFACE = 185; // 0xB9
236 public static final int INVOKEDYNAMIC = 186; // 0xBA
237 public static final int NEW = 187; // 0xBB
238 public static final int NEWARRAY = 188; // 0xBC
239 public static final int ANEWARRAY = 189; // 0xBD
240 public static final int ARRAYLENGTH = 190; // 0xBE
241 public static final int ATHROW = 191; // 0xBF
242 public static final int CHECKCAST = 192; // 0xC0
243 public static final int INSTANCEOF = 193; // 0xC1
244 public static final int MONITORENTER = 194; // 0xC2
245 public static final int MONITOREXIT = 195; // 0xC3
246 public static final int WIDE = 196; // 0xC4
247 public static final int MULTIANEWARRAY = 197; // 0xC5
248 public static final int IFNULL = 198; // 0xC6
249 public static final int IFNONNULL = 199; // 0xC7
250 public static final int GOTO_W = 200; // 0xC8
251 public static final int JSR_W = 201; // 0xC9
252 public static final int BREAKPOINT = 202; // 0xCA
253
254 public static final int ILLEGAL = 255;
255 public static final int END = 256;
256 // @formatter:on
257
258 /**
259 * The last opcode defined by the JVM specification. To iterate over all JVM bytecodes:
260 *
261 * <pre>
262 * for (int opcode = 0; opcode <= Bytecodes.LAST_JVM_OPCODE; ++opcode) {
263 * //
264 * }
265 * </pre>
266 */
267 public static final int LAST_JVM_OPCODE = JSR_W;
268
269 /**
270 * A collection of flags describing various bytecode attributes.
271 */
272 static class Flags {
273
274 /**
275 * Denotes an instruction that ends a basic block and does not let control flow fall through
276 * to its lexical successor.
277 */
278 static final int STOP = 0x00000001;
279
280 /**
281 * Denotes an instruction that ends a basic block and may let control flow fall through to
282 * its lexical successor. In practice this means it is a conditional branch.
283 */
284 static final int FALL_THROUGH = 0x00000002;
285
286 /**
287 * Denotes an instruction that has a 2 or 4 byte operand that is an offset to another
288 * instruction in the same method. This does not include the {@link Bytecodes#TABLESWITCH}
289 * or {@link Bytecodes#LOOKUPSWITCH} instructions.
290 */
291 static final int BRANCH = 0x00000004;
292
293 /**
294 * Denotes an instruction that reads the value of a static or instance field.
295 */
296 static final int FIELD_READ = 0x00000008;
297
298 /**
299 * Denotes an instruction that writes the value of a static or instance field.
300 */
301 static final int FIELD_WRITE = 0x00000010;
302
303 /**
304 * Denotes an instruction that can cause a trap.
305 */
306 static final int TRAP = 0x00000080;
307 /**
308 * Denotes an instruction that is commutative.
309 */
310 static final int COMMUTATIVE = 0x00000100;
311 /**
312 * Denotes an instruction that is associative.
313 */
314 static final int ASSOCIATIVE = 0x00000200;
315 /**
316 * Denotes an instruction that loads an operand.
317 */
318 static final int LOAD = 0x00000400;
319 /**
320 * Denotes an instruction that stores an operand.
321 */
322 static final int STORE = 0x00000800;
323 /**
324 * Denotes the 4 INVOKE* instructions.
325 */
326 static final int INVOKE = 0x00001000;
327 }
328
329 // Performs a sanity check that none of the flags overlap.
330 static {
331 int allFlags = 0;
332 try {
333 for (Field field : Flags.class.getDeclaredFields()) {
334 int flagsFilter = Modifier.FINAL | Modifier.STATIC;
335 if ((field.getModifiers() & flagsFilter) == flagsFilter && !field.isSynthetic()) {
336 assert field.getType() == int.class : "Field is not int : " + field;
337 final int flag = field.getInt(null);
338 assert flag != 0;
339 assert (flag & allFlags) == 0 : field.getName() + " has a value conflicting with another flag";
340 allFlags |= flag;
341 }
342 }
343 } catch (Exception e) {
344 throw new InternalError(e.toString());
345 }
346 }
347
348 /**
349 * An array that maps from a bytecode value to a {@link String} for the corresponding
350 * instruction mnemonic.
351 */
352 private static final String[] nameArray = new String[256];
353
354 /**
355 * An array that maps from a bytecode value to the set of {@link Flags} for the corresponding
356 * instruction.
357 */
358 private static final int[] flagsArray = new int[256];
359
360 /**
361 * An array that maps from a bytecode value to the length in bytes for the corresponding
362 * instruction.
363 */
364 private static final int[] lengthArray = new int[256];
365
366 /**
367 * An array that maps from a bytecode value to the number of slots pushed on the stack by the
368 * corresponding instruction.
369 */
370 private static final int[] stackEffectArray = new int[256];
371
372 // Checkstyle: stop
373 // @formatter:off
374 static {
375 def(NOP , "nop" , "b" , 0);
376 def(ACONST_NULL , "aconst_null" , "b" , 1);
377 def(ICONST_M1 , "iconst_m1" , "b" , 1);
378 def(ICONST_0 , "iconst_0" , "b" , 1);
379 def(ICONST_1 , "iconst_1" , "b" , 1);
380 def(ICONST_2 , "iconst_2" , "b" , 1);
381 def(ICONST_3 , "iconst_3" , "b" , 1);
382 def(ICONST_4 , "iconst_4" , "b" , 1);
383 def(ICONST_5 , "iconst_5" , "b" , 1);
384 def(LCONST_0 , "lconst_0" , "b" , 2);
385 def(LCONST_1 , "lconst_1" , "b" , 2);
386 def(FCONST_0 , "fconst_0" , "b" , 1);
387 def(FCONST_1 , "fconst_1" , "b" , 1);
388 def(FCONST_2 , "fconst_2" , "b" , 1);
389 def(DCONST_0 , "dconst_0" , "b" , 2);
390 def(DCONST_1 , "dconst_1" , "b" , 2);
391 def(BIPUSH , "bipush" , "bc" , 1);
392 def(SIPUSH , "sipush" , "bcc" , 1);
393 def(LDC , "ldc" , "bi" , 1, TRAP);
394 def(LDC_W , "ldc_w" , "bii" , 1, TRAP);
395 def(LDC2_W , "ldc2_w" , "bii" , 2, TRAP);
396 def(ILOAD , "iload" , "bi" , 1, LOAD);
397 def(LLOAD , "lload" , "bi" , 2, LOAD);
398 def(FLOAD , "fload" , "bi" , 1, LOAD);
399 def(DLOAD , "dload" , "bi" , 2, LOAD);
400 def(ALOAD , "aload" , "bi" , 1, LOAD);
401 def(ILOAD_0 , "iload_0" , "b" , 1, LOAD);
402 def(ILOAD_1 , "iload_1" , "b" , 1, LOAD);
403 def(ILOAD_2 , "iload_2" , "b" , 1, LOAD);
404 def(ILOAD_3 , "iload_3" , "b" , 1, LOAD);
405 def(LLOAD_0 , "lload_0" , "b" , 2, LOAD);
406 def(LLOAD_1 , "lload_1" , "b" , 2, LOAD);
407 def(LLOAD_2 , "lload_2" , "b" , 2, LOAD);
408 def(LLOAD_3 , "lload_3" , "b" , 2, LOAD);
409 def(FLOAD_0 , "fload_0" , "b" , 1, LOAD);
410 def(FLOAD_1 , "fload_1" , "b" , 1, LOAD);
411 def(FLOAD_2 , "fload_2" , "b" , 1, LOAD);
412 def(FLOAD_3 , "fload_3" , "b" , 1, LOAD);
413 def(DLOAD_0 , "dload_0" , "b" , 2, LOAD);
414 def(DLOAD_1 , "dload_1" , "b" , 2, LOAD);
415 def(DLOAD_2 , "dload_2" , "b" , 2, LOAD);
416 def(DLOAD_3 , "dload_3" , "b" , 2, LOAD);
417 def(ALOAD_0 , "aload_0" , "b" , 1, LOAD);
418 def(ALOAD_1 , "aload_1" , "b" , 1, LOAD);
419 def(ALOAD_2 , "aload_2" , "b" , 1, LOAD);
420 def(ALOAD_3 , "aload_3" , "b" , 1, LOAD);
421 def(IALOAD , "iaload" , "b" , -1, TRAP);
422 def(LALOAD , "laload" , "b" , 0, TRAP);
423 def(FALOAD , "faload" , "b" , -1, TRAP);
424 def(DALOAD , "daload" , "b" , 0, TRAP);
425 def(AALOAD , "aaload" , "b" , -1, TRAP);
426 def(BALOAD , "baload" , "b" , -1, TRAP);
427 def(CALOAD , "caload" , "b" , -1, TRAP);
428 def(SALOAD , "saload" , "b" , -1, TRAP);
429 def(ISTORE , "istore" , "bi" , -1, STORE);
430 def(LSTORE , "lstore" , "bi" , -2, STORE);
431 def(FSTORE , "fstore" , "bi" , -1, STORE);
432 def(DSTORE , "dstore" , "bi" , -2, STORE);
433 def(ASTORE , "astore" , "bi" , -1, STORE);
434 def(ISTORE_0 , "istore_0" , "b" , -1, STORE);
435 def(ISTORE_1 , "istore_1" , "b" , -1, STORE);
436 def(ISTORE_2 , "istore_2" , "b" , -1, STORE);
437 def(ISTORE_3 , "istore_3" , "b" , -1, STORE);
438 def(LSTORE_0 , "lstore_0" , "b" , -2, STORE);
439 def(LSTORE_1 , "lstore_1" , "b" , -2, STORE);
440 def(LSTORE_2 , "lstore_2" , "b" , -2, STORE);
441 def(LSTORE_3 , "lstore_3" , "b" , -2, STORE);
442 def(FSTORE_0 , "fstore_0" , "b" , -1, STORE);
443 def(FSTORE_1 , "fstore_1" , "b" , -1, STORE);
444 def(FSTORE_2 , "fstore_2" , "b" , -1, STORE);
445 def(FSTORE_3 , "fstore_3" , "b" , -1, STORE);
446 def(DSTORE_0 , "dstore_0" , "b" , -2, STORE);
447 def(DSTORE_1 , "dstore_1" , "b" , -2, STORE);
448 def(DSTORE_2 , "dstore_2" , "b" , -2, STORE);
449 def(DSTORE_3 , "dstore_3" , "b" , -2, STORE);
450 def(ASTORE_0 , "astore_0" , "b" , -1, STORE);
451 def(ASTORE_1 , "astore_1" , "b" , -1, STORE);
452 def(ASTORE_2 , "astore_2" , "b" , -1, STORE);
453 def(ASTORE_3 , "astore_3" , "b" , -1, STORE);
454 def(IASTORE , "iastore" , "b" , -3, TRAP);
455 def(LASTORE , "lastore" , "b" , -4, TRAP);
456 def(FASTORE , "fastore" , "b" , -3, TRAP);
457 def(DASTORE , "dastore" , "b" , -4, TRAP);
458 def(AASTORE , "aastore" , "b" , -3, TRAP);
459 def(BASTORE , "bastore" , "b" , -3, TRAP);
460 def(CASTORE , "castore" , "b" , -3, TRAP);
461 def(SASTORE , "sastore" , "b" , -3, TRAP);
462 def(POP , "pop" , "b" , -1);
463 def(POP2 , "pop2" , "b" , -2);
464 def(DUP , "dup" , "b" , 1);
465 def(DUP_X1 , "dup_x1" , "b" , 1);
466 def(DUP_X2 , "dup_x2" , "b" , 1);
467 def(DUP2 , "dup2" , "b" , 2);
468 def(DUP2_X1 , "dup2_x1" , "b" , 2);
469 def(DUP2_X2 , "dup2_x2" , "b" , 2);
470 def(SWAP , "swap" , "b" , 0);
471 def(IADD , "iadd" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
472 def(LADD , "ladd" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
473 def(FADD , "fadd" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
474 def(DADD , "dadd" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
475 def(ISUB , "isub" , "b" , -1);
476 def(LSUB , "lsub" , "b" , -2);
477 def(FSUB , "fsub" , "b" , -1);
478 def(DSUB , "dsub" , "b" , -2);
479 def(IMUL , "imul" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
480 def(LMUL , "lmul" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
481 def(FMUL , "fmul" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
482 def(DMUL , "dmul" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
483 def(IDIV , "idiv" , "b" , -1, TRAP);
484 def(LDIV , "ldiv" , "b" , -2, TRAP);
485 def(FDIV , "fdiv" , "b" , -1);
486 def(DDIV , "ddiv" , "b" , -2);
487 def(IREM , "irem" , "b" , -1, TRAP);
488 def(LREM , "lrem" , "b" , -2, TRAP);
489 def(FREM , "frem" , "b" , -1);
490 def(DREM , "drem" , "b" , -2);
491 def(INEG , "ineg" , "b" , 0);
492 def(LNEG , "lneg" , "b" , 0);
493 def(FNEG , "fneg" , "b" , 0);
494 def(DNEG , "dneg" , "b" , 0);
495 def(ISHL , "ishl" , "b" , -1);
496 def(LSHL , "lshl" , "b" , -1);
497 def(ISHR , "ishr" , "b" , -1);
498 def(LSHR , "lshr" , "b" , -1);
499 def(IUSHR , "iushr" , "b" , -1);
500 def(LUSHR , "lushr" , "b" , -1);
501 def(IAND , "iand" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
502 def(LAND , "land" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
503 def(IOR , "ior" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
504 def(LOR , "lor" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
505 def(IXOR , "ixor" , "b" , -1, COMMUTATIVE | ASSOCIATIVE);
506 def(LXOR , "lxor" , "b" , -2, COMMUTATIVE | ASSOCIATIVE);
507 def(IINC , "iinc" , "bic" , 0, LOAD | STORE);
508 def(I2L , "i2l" , "b" , 1);
509 def(I2F , "i2f" , "b" , 0);
510 def(I2D , "i2d" , "b" , 1);
511 def(L2I , "l2i" , "b" , -1);
512 def(L2F , "l2f" , "b" , -1);
513 def(L2D , "l2d" , "b" , 0);
514 def(F2I , "f2i" , "b" , 0);
515 def(F2L , "f2l" , "b" , 1);
516 def(F2D , "f2d" , "b" , 1);
517 def(D2I , "d2i" , "b" , -1);
518 def(D2L , "d2l" , "b" , 0);
519 def(D2F , "d2f" , "b" , -1);
520 def(I2B , "i2b" , "b" , 0);
521 def(I2C , "i2c" , "b" , 0);
522 def(I2S , "i2s" , "b" , 0);
523 def(LCMP , "lcmp" , "b" , -3);
524 def(FCMPL , "fcmpl" , "b" , -1);
525 def(FCMPG , "fcmpg" , "b" , -1);
526 def(DCMPL , "dcmpl" , "b" , -3);
527 def(DCMPG , "dcmpg" , "b" , -3);
528 def(IFEQ , "ifeq" , "boo" , -1, FALL_THROUGH | BRANCH);
529 def(IFNE , "ifne" , "boo" , -1, FALL_THROUGH | BRANCH);
530 def(IFLT , "iflt" , "boo" , -1, FALL_THROUGH | BRANCH);
531 def(IFGE , "ifge" , "boo" , -1, FALL_THROUGH | BRANCH);
532 def(IFGT , "ifgt" , "boo" , -1, FALL_THROUGH | BRANCH);
533 def(IFLE , "ifle" , "boo" , -1, FALL_THROUGH | BRANCH);
534 def(IF_ICMPEQ , "if_icmpeq" , "boo" , -2, COMMUTATIVE | FALL_THROUGH | BRANCH);
535 def(IF_ICMPNE , "if_icmpne" , "boo" , -2, COMMUTATIVE | FALL_THROUGH | BRANCH);
536 def(IF_ICMPLT , "if_icmplt" , "boo" , -2, FALL_THROUGH | BRANCH);
537 def(IF_ICMPGE , "if_icmpge" , "boo" , -2, FALL_THROUGH | BRANCH);
538 def(IF_ICMPGT , "if_icmpgt" , "boo" , -2, FALL_THROUGH | BRANCH);
539 def(IF_ICMPLE , "if_icmple" , "boo" , -2, FALL_THROUGH | BRANCH);
540 def(IF_ACMPEQ , "if_acmpeq" , "boo" , -2, COMMUTATIVE | FALL_THROUGH | BRANCH);
541 def(IF_ACMPNE , "if_acmpne" , "boo" , -2, COMMUTATIVE | FALL_THROUGH | BRANCH);
542 def(GOTO , "goto" , "boo" , 0, STOP | BRANCH);
543 def(JSR , "jsr" , "boo" , 0, STOP | BRANCH);
544 def(RET , "ret" , "bi" , 0, STOP);
545 def(TABLESWITCH , "tableswitch" , "" , -1, STOP);
546 def(LOOKUPSWITCH , "lookupswitch" , "" , -1, STOP);
547 def(IRETURN , "ireturn" , "b" , -1, TRAP | STOP);
548 def(LRETURN , "lreturn" , "b" , -2, TRAP | STOP);
549 def(FRETURN , "freturn" , "b" , -1, TRAP | STOP);
550 def(DRETURN , "dreturn" , "b" , -2, TRAP | STOP);
551 def(ARETURN , "areturn" , "b" , -1, TRAP | STOP);
552 def(RETURN , "return" , "b" , 0, TRAP | STOP);
553 def(GETSTATIC , "getstatic" , "bjj" , 1, TRAP | FIELD_READ);
554 def(PUTSTATIC , "putstatic" , "bjj" , -1, TRAP | FIELD_WRITE);
555 def(GETFIELD , "getfield" , "bjj" , 0, TRAP | FIELD_READ);
556 def(PUTFIELD , "putfield" , "bjj" , -2, TRAP | FIELD_WRITE);
557 def(INVOKEVIRTUAL , "invokevirtual" , "bjj" , -1, TRAP | INVOKE);
558 def(INVOKESPECIAL , "invokespecial" , "bjj" , -1, TRAP | INVOKE);
559 def(INVOKESTATIC , "invokestatic" , "bjj" , 0, TRAP | INVOKE);
560 def(INVOKEINTERFACE , "invokeinterface" , "bjja_", -1, TRAP | INVOKE);
561 def(INVOKEDYNAMIC , "invokedynamic" , "bjjjj", 0, TRAP | INVOKE);
562 def(NEW , "new" , "bii" , 1, TRAP);
563 def(NEWARRAY , "newarray" , "bc" , 0, TRAP);
564 def(ANEWARRAY , "anewarray" , "bii" , 0, TRAP);
565 def(ARRAYLENGTH , "arraylength" , "b" , 0, TRAP);
566 def(ATHROW , "athrow" , "b" , -1, TRAP | STOP);
567 def(CHECKCAST , "checkcast" , "bii" , 0, TRAP);
568 def(INSTANCEOF , "instanceof" , "bii" , 0, TRAP);
569 def(MONITORENTER , "monitorenter" , "b" , -1, TRAP);
570 def(MONITOREXIT , "monitorexit" , "b" , -1, TRAP);
571 def(WIDE , "wide" , "" , 0);
572 def(MULTIANEWARRAY , "multianewarray" , "biic" , 1, TRAP);
573 def(IFNULL , "ifnull" , "boo" , -1, FALL_THROUGH | BRANCH);
574 def(IFNONNULL , "ifnonnull" , "boo" , -1, FALL_THROUGH | BRANCH);
575 def(GOTO_W , "goto_w" , "boooo", 0, STOP | BRANCH);
576 def(JSR_W , "jsr_w" , "boooo", 0, STOP | BRANCH);
577 def(BREAKPOINT , "breakpoint" , "b" , 0, TRAP);
578 }
579 // @formatter:on
580 // Checkstyle: resume
581
582 /**
583 * Determines if an opcode is commutative.
584 *
585 * @param opcode the opcode to check
586 * @return {@code true} iff commutative
587 */
588 public static boolean isCommutative(int opcode) {
589 return (flagsArray[opcode & 0xff] & COMMUTATIVE) != 0;
590 }
591
592 /**
593 * Gets the length of an instruction denoted by a given opcode.
594 *
595 * @param opcode an instruction opcode
596 * @return the length of the instruction denoted by {@code opcode}. If {@code opcode} is an
597 * illegal instruction or denotes a variable length instruction (e.g.
598 * {@link #TABLESWITCH}), then 0 is returned.
599 */
600 public static int lengthOf(int opcode) {
601 return lengthArray[opcode & 0xff];
602 }
603
604 /**
605 * Gets the effect on the depth of the expression stack of an instruction denoted by a given
606 * opcode.
607 *
608 * @param opcode an instruction opcode
609 * @return the change in the stack caused by the instruction denoted by {@code opcode}. If
610 * {@code opcode} is an illegal instruction then 0 is returned. Note that invoke
611 * instructions may pop more arguments so this value is a minimum stack effect.
612 */
613 public static int stackEffectOf(int opcode) {
614 return stackEffectArray[opcode & 0xff];
615 }
616
617 /**
618 * Gets the lower-case mnemonic for a given opcode.
619 *
620 * @param opcode an opcode
621 * @return the mnemonic for {@code opcode} or {@code "<illegal opcode: " + opcode + ">"} if
622 * {@code opcode} is not a legal opcode
623 */
624 public static String nameOf(int opcode) throws IllegalArgumentException {
625 String name = nameArray[opcode & 0xff];
626 if (name == null) {
627 return "<illegal opcode: " + opcode + ">";
628 }
629 return name;
630 }
631
632 /**
633 * Allocation-free version of {@linkplain #nameOf(int)}.
634 *
635 * @param opcode an opcode.
636 * @return the mnemonic for {@code opcode} or {@code "<illegal opcode>"} if {@code opcode} is
637 * not a legal opcode.
638 */
639 public static String baseNameOf(int opcode) {
640 String name = nameArray[opcode & 0xff];
641 if (name == null) {
642 return "<illegal opcode>";
643 }
644 return name;
645 }
646
647 /**
648 * Gets the opcode corresponding to a given mnemonic.
649 *
650 * @param name an opcode mnemonic
651 * @return the opcode corresponding to {@code mnemonic}
652 * @throws IllegalArgumentException if {@code name} does not denote a valid opcode
653 */
654 public static int valueOf(String name) {
655 for (int opcode = 0; opcode < nameArray.length; ++opcode) {
656 if (name.equalsIgnoreCase(nameArray[opcode])) {
657 return opcode;
658 }
659 }
660 throw new IllegalArgumentException("No opcode for " + name);
661 }
662
663 /**
664 * Determines if a given opcode denotes an instruction that can cause an implicit exception.
665 *
666 * @param opcode an opcode to test
667 * @return {@code true} iff {@code opcode} can cause an implicit exception, {@code false}
668 * otherwise
669 */
670 public static boolean canTrap(int opcode) {
671 return (flagsArray[opcode & 0xff] & TRAP) != 0;
672 }
673
674 /**
675 * Determines if a given opcode denotes an instruction that loads a local variable to the
676 * operand stack.
677 *
678 * @param opcode an opcode to test
679 * @return {@code true} iff {@code opcode} loads a local variable to the operand stack,
680 * {@code false} otherwise
681 */
682 public static boolean isLoad(int opcode) {
683 return (flagsArray[opcode & 0xff] & LOAD) != 0;
684 }
685
686 /**
687 * Determines if a given opcode denotes an instruction that ends a basic block and does not let
688 * control flow fall through to its lexical successor.
689 *
690 * @param opcode an opcode to test
691 * @return {@code true} iff {@code opcode} properly ends a basic block
692 */
693 public static boolean isStop(int opcode) {
694 return (flagsArray[opcode & 0xff] & STOP) != 0;
695 }
696
697 /**
698 * Determines if a given opcode denotes an instruction that stores a value to a local variable
699 * after popping it from the operand stack.
700 *
701 * @param opcode an opcode to test
702 * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false}
703 * otherwise
704 */
705 public static boolean isInvoke(int opcode) {
706 return (flagsArray[opcode & 0xff] & INVOKE) != 0;
707 }
708
709 /**
710 * Determines if a given opcode denotes an instruction that stores a value to a local variable
711 * after popping it from the operand stack.
712 *
713 * @param opcode an opcode to test
714 * @return {@code true} iff {@code opcode} stores a value to a local variable, {@code false}
715 * otherwise
716 */
717 public static boolean isStore(int opcode) {
718 return (flagsArray[opcode & 0xff] & STORE) != 0;
719 }
720
721 /**
722 * Determines if a given opcode is an instruction that delimits a basic block.
723 *
724 * @param opcode an opcode to test
725 * @return {@code true} iff {@code opcode} delimits a basic block
726 */
727 public static boolean isBlockEnd(int opcode) {
728 return (flagsArray[opcode & 0xff] & (STOP | FALL_THROUGH)) != 0;
729 }
730
731 /**
732 * Determines if a given opcode is an instruction that has a 2 or 4 byte operand that is an
733 * offset to another instruction in the same method. This does not include the
734 * {@linkplain #TABLESWITCH switch} instructions.
735 *
736 * @param opcode an opcode to test
737 * @return {@code true} iff {@code opcode} is a branch instruction with a single operand
738 */
739 public static boolean isBranch(int opcode) {
740 return (flagsArray[opcode & 0xff] & BRANCH) != 0;
741 }
742
743 /**
744 * Determines if a given opcode denotes a conditional branch.
745 *
746 * @param opcode
747 * @return {@code true} iff {@code opcode} is a conditional branch
748 */
749 public static boolean isConditionalBranch(int opcode) {
750 return (flagsArray[opcode & 0xff] & FALL_THROUGH) != 0;
751 }
752
753 /**
754 * Gets the arithmetic operator name for a given opcode. If {@code opcode} does not denote an
755 * arithmetic instruction, then the {@linkplain #nameOf(int) name} of the opcode is returned
756 * instead.
757 *
758 * @param op an opcode
759 * @return the arithmetic operator name
760 */
761 public static String operator(int op) {
762 // Checkstyle: stop
763 switch (op) {
764 // arithmetic ops
765 case IADD: // fall through
766 case LADD: // fall through
767 case FADD: // fall through
768 case DADD:
769 return "+";
770 case ISUB: // fall through
771 case LSUB: // fall through
772 case FSUB: // fall through
773 case DSUB:
774 return "-";
775 case IMUL: // fall through
776 case LMUL: // fall through
777 case FMUL: // fall through
778 case DMUL:
779 return "*";
780 case IDIV: // fall through
781 case LDIV: // fall through
782 case FDIV: // fall through
783 case DDIV:
784 return "/";
785 case IREM: // fall through
786 case LREM: // fall through
787 case FREM: // fall through
788 case DREM:
789 return "%";
790 // shift ops
791 case ISHL: // fall through
792 case LSHL:
793 return "<<";
794 case ISHR: // fall through
795 case LSHR:
796 return ">>";
797 case IUSHR: // fall through
798 case LUSHR:
799 return ">>>";
800 // logic ops
801 case IAND: // fall through
802 case LAND:
803 return "&";
804 case IOR: // fall through
805 case LOR:
806 return "|";
807 case IXOR: // fall through
808 case LXOR:
809 return "^";
810 }
811 // Checkstyle: resume
812 return nameOf(op);
813 }
814
815 /**
816 * Defines a bytecode by entering it into the arrays that record its name, length and flags.
817 *
818 * @param name instruction name (should be lower case)
819 * @param format encodes the length of the instruction
820 */
821 private static void def(int opcode, String name, String format, int stackEffect) {
822 def(opcode, name, format, stackEffect, 0);
823 }
824
825 /**
826 * Defines a bytecode by entering it into the arrays that record its name, length and flags.
827 *
828 * @param name instruction name (lower case)
829 * @param format encodes the length of the instruction
830 * @param flags the set of {@link Flags} associated with the instruction
831 */
832 private static void def(int opcode, String name, String format, int stackEffect, int flags) {
833 assert nameArray[opcode] == null : "opcode " + opcode + " is already bound to name " + nameArray[opcode];
834 nameArray[opcode] = name;
835 int instructionLength = format.length();
836 lengthArray[opcode] = instructionLength;
837 stackEffectArray[opcode] = stackEffect;
838 Bytecodes.flagsArray[opcode] = flags;
839
840 assert !isConditionalBranch(opcode) || isBranch(opcode) : "a conditional branch must also be a branch";
841 }
842
843 public static boolean isIfBytecode(int bytecode) {
844 switch (bytecode) {
845 case IFEQ:
846 case IFNE:
847 case IFLT:
848 case IFGE:
849 case IFGT:
850 case IFLE:
851 case IF_ICMPEQ:
852 case IF_ICMPNE:
853 case IF_ICMPLT:
854 case IF_ICMPGE:
855 case IF_ICMPGT:
856 case IF_ICMPLE:
857 case IF_ACMPEQ:
858 case IF_ACMPNE:
859 case IFNULL:
860 case IFNONNULL:
861 return true;
862 }
863 return false;
864 }
865 }