org.eclipse.jdt.core.util

## Interface IBytecodeVisitor

All Known Implementing Classes:
  ByteCodeVisitorAdapter

    public interface IBytecodeVisitor

Description of a Java opcodes visitor. This should be used to walk the opcodes of a ICodeAttribute. Clients must subclass `ByteCodeVisitorAdapter` to define an implementation of this interface.

Since:
  2.0
Restriction:
  This interface is not intended to be implemented by clients.

### Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
`void` `_aaload(int pc)`
`void` `_aastore(int pc)`
`void` `_aconst_null(int pc)`
`void` `_aload_0(int pc)`
`void` `_aload_1(int pc)`
`void` `_aload_2(int pc)`
`void` `_aload_3(int pc)`
`void` `_aload(int pc, int index)`
`void` `_anewarray(int pc, int index, IConstantPoolEntry constantClass)`
`void` `_areturn(int pc)`
`void` `_arraylength(int pc)`
`void` `_astore_0(int pc)`
`void` `_astore_1(int pc)`
`void` `_astore_2(int pc)`
`void` `_astore_3(int pc)`
`void` `_astore(int pc, int index)`
`void` `_athrow(int pc)`
`void` `_baload(int pc)`
`void` `_bastore(int pc)`
`void` `_bipush(int pc, byte _byte)`
`void` `_breakpoint(int pc)`
`void` `_caload(int pc)`
`void` `_castore(int pc)`
`void` `_checkcast(int pc, int index, IConstantPoolEntry constantClass)`
`void` `_d2f(int pc)`
`void` `_d2i(int pc)`
`void` `_d2l(int pc)`
`void` `_dadd(int pc)`
`void` `_daload(int pc)`
`void` `_dastore(int pc)`
`void` `_dcmpg(int pc)`
`void` `_dcmpl(int pc)`
`void` `_dconst_0(int pc)`
`void` `_dconst_1(int pc)`
`void` `_ddiv(int pc)`
`void` `_dload_0(int pc)`
`void` `_dload_1(int pc)`
`void` `_dload_2(int pc)`
`void` `_dload_3(int pc)`
`void` `_dload(int pc, int index)`
`void` `_dmul(int pc)`
`void` `_dneg(int pc)`
`void` `_drem(int pc)`
`void` `_dreturn(int pc)`
`void` `_dstore_0(int pc)`
`void` `_dstore_1(int pc)`
`void` `_dstore_2(int pc)`
`void` `_dstore_3(int pc)`
`void` `_dstore(int pc, int index)`
`void` `_dsub(int pc)`
`void` `_dup_x1(int pc)`
`void` `_dup_x2(int pc)`
`void` `_dup(int pc)`
`void` `_dup2_x1(int pc)`
`void` `_dup2_x2(int pc)`
`void` `_dup2(int pc)`
`void` `_f2d(int pc)`
`void` `_f2i(int pc)`
`void` `_f2l(int pc)`
`void` `_fadd(int pc)`
`void` `_faload(int pc)`
`void` `_fastore(int pc)`
`void` `_fcmpg(int pc)`
`void` `_fcmpl(int pc)`
`void` `_fconst_0(int pc)`
`void` `_fconst_1(int pc)`
`void` `_fconst_2(int pc)`
`void` `_fdiv(int pc)`
`void` `_fload_0(int pc)`
`void` `_fload_1(int pc)`
`void` `_fload_2(int pc)`
`void` `_fload_3(int pc)`
`void` `_fload(int pc, int index)`
`void` `_fmul(int pc)`
`void` `_fneg(int pc)`
`void` `_frem(int pc)`
`void` `_freturn(int pc)`
`void` `_fstore_0(int pc)`
`void` `_fstore_1(int pc)`
`void` `_fstore_2(int pc)`
`void` `_fstore_3(int pc)`
`void` `_fstore(int pc, int index)`
`void` `_fsub(int pc)`
`void` `_getfield(int pc, int index, IConstantPoolEntry constantFieldref)`
`void` `_getstatic(int pc, int index, IConstantPoolEntry constantFieldref)`
`void` `_goto_w(int pc, int branchOffset)`
`void` `_goto(int pc, int branchOffset)`
`void` `_i2b(int pc)`
`void` `_i2c(int pc)`
`void` `_i2d(int pc)`
`void` `_i2f(int pc)`
`void` `_i2l(int pc)`
`void` `_i2s(int pc)`
`void` `_iadd(int pc)`
`void` `_iaload(int pc)`
`void` `_iand(int pc)`
`void` `_iastore(int pc)`
`void` `_iconst_0(int pc)`
`void` `_iconst_1(int pc)`
`void` `_iconst_2(int pc)`
`void` `_iconst_3(int pc)`
`void` `_iconst_4(int pc)`
`void` `_iconst_5(int pc)`
`void` `_iconst_m1(int pc)`
`void` `_idiv(int pc)`
`void` `_if_acmpeq(int pc, int branchOffset)`
`void` `_if_acmpne(int pc, int branchOffset)`
`void` `_if_icmpeq(int pc, int branchOffset)`
`void` `_if_icmpge(int pc, int branchOffset)`
`void` `_if_icmpgt(int pc, int branchOffset)`
`void` `_if_icmple(int pc, int branchOffset)`
`void` `_if_icmplt(int pc, int branchOffset)`
`void` `_if_icmpne(int pc, int branchOffset)`
`void` `_ifeq(int pc, int branchOffset)`
`void` `_ifge(int pc, int branchOffset)`
`void` `_ifgt(int pc, int branchOffset)`
`void` `_ifle(int pc, int branchOffset)`
`void` `_iflt(int pc, int branchOffset)`
`void` `_ifne(int pc, int branchOffset)`
`void` `_ifnonnull(int pc, int branchOffset)`
`void` `_ifnull(int pc, int branchOffset)`
`void` `_iinc(int pc, int index, int _const)`
`void` `_iload_0(int pc)`
`void` `_iload_1(int pc)`
`void` `_iload_2(int pc)`
`void` `_iload_3(int pc)`
`void` `_iload(int pc, int index)`
`void` `_impdep1(int pc)`
`void` `_impdep2(int pc)`
`void` `_imul(int pc)`
`void` `_ineg(int pc)`
`void` `_instanceof(int pc, int index, IConstantPoolEntry constantClass)`
`void` `_invokedynamic(int pc, int index, IConstantPoolEntry invokeDynamic)`
`void` `_invokedynamic(int pc, int index, IConstantPoolEntry nameEntry, IConstantPoolEntry descriptorEntry)` Deprecated. This has been replaced with `_invokedynamic(int, int, IConstantPoolEntry)`
`void` `_invokeinterface(int pc, int index, byte nargs, IConstantPoolEntry constantInterfaceMethodref)`
`void` `_invokespecial(int pc, int index, IConstantPoolEntry constantMethodref)`
`void` `_invokestatic(int pc, int index, IConstantPoolEntry constantMethodref)`
`void` `_invokevirtual(int pc, int index, IConstantPoolEntry constantMethodref)`
`void` `_ior(int pc)`
`void` `_irem(int pc)`
`void` `_ireturn(int pc)`
`void` `_ishl(int pc)`
`void` `_ishr(int pc)`
`void` `_istore_0(int pc)`
`void` `_istore_1(int pc)`
`void` `_istore_2(int pc)`
`void` `_istore_3(int pc)`
`void` `_istore(int pc, int index)`
`void` `_isub(int pc)`
`void` `_iushr(int pc)`
`void` `_ixor(int pc)`
`void` `_jsr_w(int pc, int branchOffset)`
`void` `_jsr(int pc, int branchOffset)`
`void` `_l2d(int pc)`
`void` `_l2f(int pc)`
`void` `_l2i(int pc)`
`void` `_ladd(int pc)`
`void` `_laload(int pc)`
`void` `_land(int pc)`
`void` `_lastore(int pc)`
`void` `_lcmp(int pc)`
`void` `_lconst_0(int pc)`
`void` `_lconst_1(int pc)`
`void` `_ldc_w(int pc, int index, IConstantPoolEntry constantPoolEntry)`
`void` `_ldc(int pc, int index, IConstantPoolEntry constantPoolEntry)`
`void` `_ldc2_w(int pc, int index, IConstantPoolEntry constantPoolEntry)`
`void` `_ldiv(int pc)`
`void` `_lload_0(int pc)`
`void` `_lload_1(int pc)`
`void` `_lload_2(int pc)`
`void` `_lload_3(int pc)`
`void` `_lload(int pc, int index)`
`void` `_lmul(int pc)`
`void` `_lneg(int pc)`
`void` `_lookupswitch(int pc, int defaultoffset, int npairs, int[][] offset_pairs)`
`void` `_lor(int pc)`
`void` `_lrem(int pc)`
`void` `_lreturn(int pc)`
`void` `_lshl(int pc)`
`void` `_lshr(int pc)`
`void` `_lstore_0(int pc)`
`void` `_lstore_1(int pc)`
`void` `_lstore_2(int pc)`
`void` `_lstore_3(int pc)`
`void` `_lstore(int pc, int index)`
`void` `_lsub(int pc)`
`void` `_lushr(int pc)`
`void` `_lxor(int pc)`
`void` `_monitorenter(int pc)`
`void` `_monitorexit(int pc)`
`void` `_multianewarray(int pc, int index, int dimensions, IConstantPoolEntry constantClass)`
`void` `_new(int pc, int index, IConstantPoolEntry constantClass)`
`void` `_newarray(int pc, int atype)`
`void` `_nop(int pc)`
`void` `_pop(int pc)`
`void` `_pop2(int pc)`
`void` `_putfield(int pc, int index, IConstantPoolEntry constantFieldref)`
`void` `_putstatic(int pc, int index, IConstantPoolEntry constantFieldref)`
`void` `_ret(int pc, int index)`
`void` `_return(int pc)`
`void` `_saload(int pc)`
`void` `_sastore(int pc)`
`void` `_sipush(int pc, short value)`
`void` `_swap(int pc)`
`void` `_tableswitch(int pc, int defaultoffset, int low, int high, int[] jump_offsets)`
`void` `_wide(int pc, int opcode, int index)`
`void` `_wide(int pc, int iincopcode, int index, int _const)`

### Method Detail

#### _aaload

    void _aaload(int pc)

#### _aastore

    void _aastore(int pc)

#### _aconst_null

    void _aconst_null(int pc)

#### _aload

    void _aload(int pc,
                int index)

#### _aload_0

    void _aload_0(int pc)

#### _aload_1

    void _aload_1(int pc)

#### _aload_2

    void _aload_2(int pc)

#### _aload_3

    void _aload_3(int pc)

#### _anewarray

    void _anewarray(int pc,
                    int index,
                    IConstantPoolEntry constantClass)

#### _areturn

    void _areturn(int pc)

#### _arraylength

    void _arraylength(int pc)

#### _astore

    void _astore(int pc,
                 int index)

#### _astore_0

    void _astore_0(int pc)

#### _astore_1

    void _astore_1(int pc)

#### _astore_2

    void _astore_2(int pc)

#### _astore_3

    void _astore_3(int pc)

#### _athrow

    void _athrow(int pc)

#### _baload

    void _baload(int pc)

#### _bastore

    void _bastore(int pc)

#### _bipush

    void _bipush(int pc,
                 byte _byte)

#### _caload

    void _caload(int pc)

#### _castore

    void _castore(int pc)

#### _checkcast

    void _checkcast(int pc,
                    int index,
                    IConstantPoolEntry constantClass)

#### _d2f

    void _d2f(int pc)

#### _d2i

    void _d2i(int pc)

#### _d2l

    void _d2l(int pc)

#### _dadd

    void _dadd(int pc)

#### _daload

    void _daload(int pc)

#### _dastore

    void _dastore(int pc)

#### _dcmpg

    void _dcmpg(int pc)

#### _dcmpl

    void _dcmpl(int pc)

#### _dconst_0

    void _dconst_0(int pc)

#### _dconst_1

    void _dconst_1(int pc)

#### _ddiv

    void _ddiv(int pc)

#### _dload

    void _dload(int pc,
                int index)

#### _dload_0

    void _dload_0(int pc)

#### _dload_1

    void _dload_1(int pc)

#### _dload_2

    void _dload_2(int pc)

#### _dload_3

    void _dload_3(int pc)

#### _dmul

    void _dmul(int pc)

#### _dneg

    void _dneg(int pc)

#### _drem

    void _drem(int pc)

#### _dreturn

    void _dreturn(int pc)

#### _dstore

    void _dstore(int pc,
                 int index)

#### _dstore_0

    void _dstore_0(int pc)

#### _dstore_1

    void _dstore_1(int pc)

#### _dstore_2

    void _dstore_2(int pc)

#### _dstore_3

    void _dstore_3(int pc)

#### _dsub

    void _dsub(int pc)

#### _dup

    void _dup(int pc)

#### _dup_x1

    void _dup_x1(int pc)

#### _dup_x2

    void _dup_x2(int pc)

#### _dup2

    void _dup2(int pc)

#### _dup2_x1

    void _dup2_x1(int pc)

#### _dup2_x2

    void _dup2_x2(int pc)

#### _f2d

    void _f2d(int pc)

#### _f2i

    void _f2i(int pc)

#### _f2l

    void _f2l(int pc)

#### _fadd

    void _fadd(int pc)

#### _faload

    void _faload(int pc)

#### _fastore

    void _fastore(int pc)

#### _fcmpg

    void _fcmpg(int pc)

#### _fcmpl

    void _fcmpl(int pc)

#### _fconst_0

    void _fconst_0(int pc)

#### _fconst_1

    void _fconst_1(int pc)

#### _fconst_2

    void _fconst_2(int pc)

#### _fdiv

    void _fdiv(int pc)

#### _fload

    void _fload(int pc,
                int index)

#### _fload_0

    void _fload_0(int pc)

#### _fload_1

    void _fload_1(int pc)

#### _fload_2

    void _fload_2(int pc)

#### _fload_3

    void _fload_3(int pc)

#### _fmul

    void _fmul(int pc)

#### _fneg

    void _fneg(int pc)

#### _frem

    void _frem(int pc)

#### _freturn

    void _freturn(int pc)

#### _fstore

    void _fstore(int pc,
                 int index)

#### _fstore_0

    void _fstore_0(int pc)

#### _fstore_1

    void _fstore_1(int pc)

#### _fstore_2

    void _fstore_2(int pc)

#### _fstore_3

    void _fstore_3(int pc)

#### _fsub

    void _fsub(int pc)

#### _getfield

    void _getfield(int pc,
                   int index,
                   IConstantPoolEntry constantFieldref)

#### _getstatic

    void _getstatic(int pc,
                    int index,
                    IConstantPoolEntry constantFieldref)

#### _goto

    void _goto(int pc,
               int branchOffset)

#### _goto_w

    void _goto_w(int pc,
                 int branchOffset)

#### _i2b

    void _i2b(int pc)

#### _i2c

    void _i2c(int pc)

#### _i2d

    void _i2d(int pc)

#### _i2f

    void _i2f(int pc)

#### _i2l

    void _i2l(int pc)

#### _i2s

    void _i2s(int pc)

#### _iadd

    void _iadd(int pc)

#### _iaload

    void _iaload(int pc)

#### _iand

    void _iand(int pc)

#### _iastore

    void _iastore(int pc)

#### _iconst_m1

    void _iconst_m1(int pc)

#### _iconst_0

    void _iconst_0(int pc)

#### _iconst_1

    void _iconst_1(int pc)

#### _iconst_2

    void _iconst_2(int pc)

#### _iconst_3

    void _iconst_3(int pc)

#### _iconst_4

    void _iconst_4(int pc)

#### _iconst_5

    void _iconst_5(int pc)

#### _idiv

    void _idiv(int pc)

#### _if_acmpeq

    void _if_acmpeq(int pc,
                    int branchOffset)

#### _if_acmpne

    void _if_acmpne(int pc,
                    int branchOffset)

#### _if_icmpeq

    void _if_icmpeq(int pc,
                    int branchOffset)

#### _if_icmpne

    void _if_icmpne(int pc,
                    int branchOffset)

#### _if_icmplt

    void _if_icmplt(int pc,
                    int branchOffset)

#### _if_icmpge

    void _if_icmpge(int pc,
                    int branchOffset)

#### _if_icmpgt

    void _if_icmpgt(int pc,
                    int branchOffset)

#### _if_icmple

    void _if_icmple(int pc,
                    int branchOffset)

#### _ifeq

    void _ifeq(int pc,
               int branchOffset)

#### _ifne

    void _ifne(int pc,
               int branchOffset)

#### _iflt

    void _iflt(int pc,
               int branchOffset)

#### _ifge

    void _ifge(int pc,
               int branchOffset)

#### _ifgt

    void _ifgt(int pc,
               int branchOffset)

#### _ifle

    void _ifle(int pc,
               int branchOffset)

#### _ifnonnull

    void _ifnonnull(int pc,
                    int branchOffset)

#### _ifnull

    void _ifnull(int pc,
                 int branchOffset)

#### _iinc

    void _iinc(int pc,
               int index,
               int _const)

#### _iload

    void _iload(int pc,
                int index)

#### _iload_0

    void _iload_0(int pc)

#### _iload_1

    void _iload_1(int pc)

#### _iload_2

    void _iload_2(int pc)

#### _iload_3

    void _iload_3(int pc)

#### _imul

    void _imul(int pc)

#### _ineg

    void _ineg(int pc)

#### _instanceof

    void _instanceof(int pc,
                     int index,
                     IConstantPoolEntry constantClass)

#### _invokedynamic

    void _invokedynamic(int pc,
                        int index,
                        IConstantPoolEntry nameEntry,
                        IConstantPoolEntry descriptorEntry)

Deprecated. This has been replaced with `_invokedynamic(int, int, IConstantPoolEntry)`

Since:
  3.6

#### _invokedynamic

    void _invokedynamic(int pc,
                        int index,
                        IConstantPoolEntry invokeDynamic)

Since:
  3.8

#### _invokeinterface

    void _invokeinterface(int pc,
                          int index,
                          byte nargs,
                          IConstantPoolEntry constantInterfaceMethodref)

#### _invokespecial

    void _invokespecial(int pc,
                        int index,
                        IConstantPoolEntry constantMethodref)

#### _invokestatic

    void _invokestatic(int pc,
                       int index,
                       IConstantPoolEntry constantMethodref)

#### _invokevirtual

    void _invokevirtual(int pc,
                        int index,
                        IConstantPoolEntry constantMethodref)

#### _ior

    void _ior(int pc)

#### _irem

    void _irem(int pc)

#### _ireturn

    void _ireturn(int pc)

#### _ishl

    void _ishl(int pc)

#### _ishr

    void _ishr(int pc)

#### _istore

    void _istore(int pc,
                 int index)

#### _istore_0

    void _istore_0(int pc)

#### _istore_1

    void _istore_1(int pc)

#### _istore_2

    void _istore_2(int pc)

#### _istore_3

    void _istore_3(int pc)

#### _isub

    void _isub(int pc)

#### _iushr

    void _iushr(int pc)

#### _ixor

    void _ixor(int pc)

#### _jsr

    void _jsr(int pc,
              int branchOffset)

#### _jsr_w

    void _jsr_w(int pc,
                int branchOffset)

#### _l2d

    void _l2d(int pc)

#### _l2f

    void _l2f(int pc)

#### _l2i

    void _l2i(int pc)

#### _ladd

    void _ladd(int pc)

#### _laload

    void _laload(int pc)

#### _land

    void _land(int pc)

#### _lastore

    void _lastore(int pc)

#### _lcmp

    void _lcmp(int pc)

#### _lconst_0

    void _lconst_0(int pc)

#### _lconst_1

    void _lconst_1(int pc)

#### _ldc

    void _ldc(int pc,
              int index,
              IConstantPoolEntry constantPoolEntry)

#### _ldc_w

    void _ldc_w(int pc,
                int index,
                IConstantPoolEntry constantPoolEntry)

#### _ldc2_w

    void _ldc2_w(int pc,
                 int index,
                 IConstantPoolEntry constantPoolEntry)

#### _ldiv

    void _ldiv(int pc)

#### _lload

    void _lload(int pc,
                int index)

#### _lload_0

    void _lload_0(int pc)

#### _lload_1

    void _lload_1(int pc)

#### _lload_2

    void _lload_2(int pc)

#### _lload_3

    void _lload_3(int pc)

#### _lmul

    void _lmul(int pc)

#### _lneg

    void _lneg(int pc)

#### _lookupswitch

    void _lookupswitch(int pc,
                       int defaultoffset,
                       int npairs,
                       int[][] offset_pairs)

#### _lor

    void _lor(int pc)

#### _lrem

    void _lrem(int pc)

#### _lreturn

    void _lreturn(int pc)

#### _lshl

    void _lshl(int pc)

#### _lshr

    void _lshr(int pc)

#### _lstore

    void _lstore(int pc,
                 int index)

#### _lstore_0

    void _lstore_0(int pc)

#### _lstore_1

    void _lstore_1(int pc)

#### _lstore_2

    void _lstore_2(int pc)

#### _lstore_3

    void _lstore_3(int pc)

#### _lsub

    void _lsub(int pc)

#### _lushr

    void _lushr(int pc)

#### _lxor

    void _lxor(int pc)

#### _monitorenter

    void _monitorenter(int pc)

#### _monitorexit

    void _monitorexit(int pc)

#### _multianewarray

    void _multianewarray(int pc,
                         int index,
                         int dimensions,
                         IConstantPoolEntry constantClass)

#### _new

    void _new(int pc,
              int index,
              IConstantPoolEntry constantClass)

#### _newarray

    void _newarray(int pc,
                   int atype)

#### _nop

    void _nop(int pc)

#### _pop

    void _pop(int pc)

#### _pop2

    void _pop2(int pc)

#### _putfield

    void _putfield(int pc,
                   int index,
                   IConstantPoolEntry constantFieldref)

#### _putstatic

    void _putstatic(int pc,
                    int index,
                    IConstantPoolEntry constantFieldref)

#### _ret

    void _ret(int pc,
              int index)

#### _return

    void _return(int pc)

#### _saload

    void _saload(int pc)

#### _sastore

    void _sastore(int pc)

#### _sipush

    void _sipush(int pc,
                 short value)

#### _swap

    void _swap(int pc)

#### _tableswitch

    void _tableswitch(int pc,
                      int defaultoffset,
                      int low,
                      int high,
                      int[] jump_offsets)

#### _wide

    void _wide(int pc,
               int opcode,
               int index)

#### _wide

    void _wide(int pc,
               int iincopcode,
               int index,
               int _const)

#### _breakpoint

    void _breakpoint(int pc)

#### _impdep1

    void _impdep1(int pc)

#### _impdep2

    void _impdep2(int pc)