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