aQute.bnd.osgi.OpCodes Maven / Gradle / Ivy
The newest version!
package aQute.bnd.osgi;
public class OpCodes {
final static short nop = 0x00; // [No change]
// performs
// no
// operation
final static short aconst_null = 0x01; // ? null pushes a
// null
// reference onto the stack
final static short iconst_m1 = 0x02; // ? -1 loads the
// int
// value -1
// onto the stack
final static short iconst_0 = 0x03; // ? 0 loads the int
// value 0
// onto the stack
final static short iconst_1 = 0x04; // ? 1 loads the int
// value 1
// onto the stack
final static short iconst_2 = 0x05; // ? 2 loads the int
// value 2
// onto the stack
final static short iconst_3 = 0x06; // ? 3 loads the int
// value 3
// onto the stack
final static short iconst_4 = 0x07; // ? 4 loads the int
// value 4
// onto the stack
final static short iconst_5 = 0x08; // ? 5 loads the int
// value 5
// onto the stack
final static short lconst_0 = 0x09; // ? 0L pushes the
// long
// 0 onto
// the stack
final static short bipush = 0x10; // byte ? value
// pushes a
// byte
// onto the stack as an integer
// value
final static short sipush = 0x11; // byte1, byte2 ?
// value
// pushes a
// signed integer (byte1 << 8 +
// byte2) onto the stack
final static short ldc = 0x12; // index ? value
// pushes
// a
// constant #index from a
// constant pool (String, int,
// float or class type) onto the
// stack
final static short ldc_w = 0x13; // indexbyte1,
// indexbyte2 ?
// value pushes a constant
// #index from a constant pool
// (String, int, float or class
// type) onto the stack (wide
// index is constructed as
// indexbyte1 << 8 + indexbyte2)
final static short ldc2_w = 0x14; // indexbyte1,
// indexbyte2 ?
// value pushes a constant
// #index from a constant pool
// (double or long) onto the
// stack (wide index is
// constructed as indexbyte1 <<
// 8 + indexbyte2)
final static short iload = 0x15; // index ? value
// loads
// an int
// value from a variable #index
final static short lload = 0x16; // index ? value
// load a
// long
// value from a local variable
// #index
final static short fload = 0x17; // index ? value
// loads a
// float
// value from a local variable
// #index
final static short dload = 0x18; // index ? value
// loads a
// double
// value from a local variable
// #index
final static short aload = 0x19; // index ? objectref
// loads a
// reference onto the stack from
// a local variable #index
final static short lload_2 = 0x20; // ? value load a
// long
// value
// from a local variable 2
final static short lload_3 = 0x21; // ? value load a
// long
// value
// from a local variable 3
final static short fload_0 = 0x22; // ? value loads a
// float
// value
// from local variable 0
final static short fload_1 = 0x23; // ? value loads a
// float
// value
// from local variable 1
final static short fload_2 = 0x24; // ? value loads a
// float
// value
// from local variable 2
final static short fload_3 = 0x25; // ? value loads a
// float
// value
// from local variable 3
final static short dload_0 = 0x26; // ? value loads a
// double from
// local variable 0
final static short dload_1 = 0x27; // ? value loads a
// double from
// local variable 1
final static short dload_2 = 0x28; // ? value loads a
// double from
// local variable 2
final static short dload_3 = 0x29; // ? value loads a
// double from
// local variable 3
final static short faload = 0x30; // arrayref, index ?
// value loads
// a float from an array
final static short daload = 0x31; // arrayref, index ?
// value loads
// a double from an array
final static short aaload = 0x32; // arrayref, index ?
// value loads
// onto the stack a reference
// from an array
final static short baload = 0x33; // arrayref, index ?
// value loads
// a byte or Boolean value from
// an array
final static short caload = 0x34; // arrayref, index ?
// value loads
// a char from an array
final static short saload = 0x35; // arrayref, index ?
// value load
// short from array
final static short istore = 0x36; // index value ?
// store
// int value
// into variable #index
final static short lstore = 0x37; // index value ?
// store a
// long
// value in a local variable
// #index
final static short fstore = 0x38; // index value ?
// stores
// a float
// value into a local variable
// #index
final static short dstore = 0x39; // index value ?
// stores
// a double
// value into a local variable
// #index
final static short lstore_1 = 0x40; // value ? store a
// long
// value in
// a local variable 1
final static short lstore_2 = 0x41; // value ? store a
// long
// value in
// a local variable 2
final static short lstore_3 = 0x42; // value ? store a
// long
// value in
// a local variable 3
final static short fstore_0 = 0x43; // value ? stores a
// float value
// into local variable 0
final static short fstore_1 = 0x44; // value ? stores a
// float value
// into local variable 1
final static short fstore_2 = 0x45; // value ? stores a
// float value
// into local variable 2
final static short fstore_3 = 0x46; // value ? stores a
// float value
// into local variable 3
final static short dstore_0 = 0x47; // value ? stores a
// double into
// local variable 0
final static short dstore_1 = 0x48; // value ? stores a
// double into
// local variable 1
final static short dstore_2 = 0x49; // value ? stores a
// double into
// local variable 2
final static short lastore = 0x50; // arrayref, index,
// value ?
// store a long to an array
final static short fastore = 0x51; // arreyref, index,
// value ?
// stores a float in an array
final static short dastore = 0x52; // arrayref, index,
// value ?
// stores a double into an array
final static short aastore = 0x53; // arrayref, index,
// value ?
// stores into a reference to an
// array
final static short bastore = 0x54; // arrayref, index,
// value ?
// stores a byte or Boolean
// value into an array
final static short castore = 0x55; // arrayref, index,
// value ?
// stores a char into an array
final static short sastore = 0x56; // arrayref, index,
// value ?
// store short to array
final static short pop = 0x57; // value ? discards
// the
// top
// value on the stack
final static short pop2 = 0x58; // {value2, value1}
// ?
// discards
// the top two values on the
// stack (or one value, if it is
// a double or long)
final static short dup = 0x59; // value ? value,
// value
// duplicates the value on top
// of the stack
final static short iadd = 0x60; // value1, value2 ?
// result adds
// two ints together
final static short ladd = 0x61; // value1, value2 ?
// result add
// two longs
final static short fadd = 0x62; // value1, value2 ?
// result adds
// two floats
final static short dadd = 0x63; // value1, value2 ?
// result adds
// two doubles
final static short isub = 0x64; // value1, value2 ?
// result int
// subtract
final static short lsub = 0x65; // value1, value2 ?
// result
// subtract two longs
final static short fsub = 0x66; // value1, value2 ?
// result
// subtracts two floats
final static short dsub = 0x67; // value1, value2 ?
// result
// subtracts a double from
// another
final static short imul = 0x68; // value1, value2 ?
// result
// multiply two integers
final static short lmul = 0x69; // value1, value2 ?
// result
// multiplies two longs
final static short irem = 0x70; // value1, value2 ?
// result
// logical int remainder
final static short lrem = 0x71; // value1, value2 ?
// result
// remainder of division of two
// longs
final static short frem = 0x72; // value1, value2 ?
// result gets
// the remainder from a division
// between two floats
final static short drem = 0x73; // value1, value2 ?
// result gets
// the remainder from a division
// between two doubles
final static short ineg = 0x74; // value ? result
// negate
// int
final static short lneg = 0x75; // value ? result
// negates a long
final static short fneg = 0x76; // value ? result
// negates a
// float
final static short dneg = 0x77; // value ? result
// negates a
// double
final static short ishl = 0x78; // value1, value2 ?
// result int
// shift left
final static short lshl = 0x79; // value1, value2 ?
// result
// bitwise shift left of a long
// value1 by value2 positions
final static short ior = 0x80; // value1, value2 ?
// result
// logical int or
final static short lor = 0x81; // value1, value2 ?
// result
// bitwise or of two longs
final static short ixor = 0x82; // value1, value2 ?
// result int
// xor
final static short lxor = 0x83; // value1, value2 ?
// result
// bitwise exclusive or of two
// longs
final static short iinc = 0x84; // index, const [No
// change]
// increment local variable
// #index by signed byte const
final static short i2l = 0x85; // value ? result
// converts an
// int into a long
final static short i2f = 0x86; // value ? result
// converts an
// int into a float
final static short i2d = 0x87; // value ? result
// converts an
// int into a double
final static short l2i = 0x88; // value ? result
// converts a
// long to an int
final static short l2f = 0x89; // value ? result
// converts a
// long to a float
final static short d2f = 0x90; // value ? result
// converts a
// double to a float
final static short i2b = 0x91; // value ? result
// converts an
// int into a byte
final static short i2c = 0x92; // value ? result
// converts an
// int into a character
final static short i2s = 0x93; // value ? result
// converts an
// int into a short
final static short lcmp = 0x94; // value1, value2 ?
// result
// compares two longs values
final static short fcmpl = 0x95; // value1, value2 ?
// result
// compares two floats
final static short fcmpg = 0x96; // value1, value2 ?
// result
// compares two floats
final static short dcmpl = 0x97; // value1, value2 ?
// result
// compares two doubles
final static short dcmpg = 0x98; // value1, value2 ?
// result
// compares two doubles
final static short ifeq = 0x99; // branchbyte1,
// branchbyte2
// value ? if value is 0, branch
// to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short lconst_1 = 0x0a; // ? 1L pushes the
// long
// 1 onto
// the stack
final static short fconst_0 = 0x0b; // ? 0.0f pushes
// 0.0f on
// the
// stack
final static short fconst_1 = 0x0c; // ? 1.0f pushes
// 1.0f on
// the
// stack
final static short fconst_2 = 0x0d; // ? 2.0f pushes
// 2.0f on
// the
// stack
final static short dconst_0 = 0x0e; // ? 0.0 pushes the
// constant 0.0
// onto the stack
final static short dconst_1 = 0x0f; // ? 1.0 pushes the
// constant 1.0
// onto the stack
final static short iload_0 = 0x1a; // ? value loads an
// int
// value
// from variable 0
final static short iload_1 = 0x1b; // ? value loads an
// int
// value
// from variable 1
final static short iload_2 = 0x1c; // ? value loads an
// int
// value
// from variable 2
final static short iload_3 = 0x1d; // ? value loads an
// int
// value
// from variable 3
final static short lload_0 = 0x1e; // ? value load a
// long
// value
// from a local variable 0
final static short lload_1 = 0x1f; // ? value load a
// long
// value
// from a local variable 1
final static short aload_0 = 0x2a; // ? objectref loads
// a
// reference
// onto the stack from local
// variable 0
final static short aload_1 = 0x2b; // ? objectref loads
// a
// reference
// onto the stack from local
// variable 1
final static short aload_2 = 0x2c; // ? objectref loads
// a
// reference
// onto the stack from local
// variable 2
final static short aload_3 = 0x2d; // ? objectref loads
// a
// reference
// onto the stack from local
// variable 3
final static short iaload = 0x2e; // arrayref, index ?
// value loads
// an int from an array
final static short laload = 0x2f; // arrayref, index ?
// value load
// a long from an array
final static short astore = 0x3a; // index objectref ?
// stores a
// reference into a local
// variable #index
final static short istore_0 = 0x3b; // value ? store int
// value into
// variable 0
final static short istore_1 = 0x3c; // value ? store int
// value into
// variable 1
final static short istore_2 = 0x3d; // value ? store int
// value into
// variable 2
final static short istore_3 = 0x3e; // value ? store int
// value into
// variable 3
final static short lstore_0 = 0x3f; // value ? store a
// long
// value in
// a local variable 0
final static short dstore_3 = 0x4a; // value ? stores a
// double into
// local variable 3
final static short astore_0 = 0x4b; // objectref ?
// stores a
// reference into local variable
// 0
final static short astore_1 = 0x4c; // objectref ?
// stores a
// reference into local variable
// 1
final static short astore_2 = 0x4d; // objectref ?
// stores a
// reference into local variable
// 2
final static short astore_3 = 0x4e; // objectref ?
// stores a
// reference into local variable
// 3
final static short iastore = 0x4f; // arrayref, index,
// value ?
// stores an int into an array
final static short dup_x1 = 0x5a; // value2, value1 ?
// value1,
// value2, value1 inserts a copy
// of the top value into the
// stack two values from the top
final static short dup_x2 = 0x5b; // value3, value2,
// value1 ?
// value1, value3, value2,
// value1 inserts a copy of the
// top value into the stack two
// (if value2 is double or long
// it takes up the entry of
// value3, too) or three values
// (if value2 is neither double
// nor long) from the top
final static short dup2 = 0x5c; // {value2, value1}
// ?
// {value2,
// value1}, {value2, value1}
// duplicate top two stack words
// (two values, if value1 is not
// double nor long; a single
// value, if value1 is double or
// long)
final static short dup2_x1 = 0x5d; // value3, {value2,
// value1} ?
// {value2, value1}, value3,
// {value2, value1} duplicate
// two words and insert beneath
// third word (see explanation
// above)
final static short dup2_x2 = 0x5e; // {value4, value3},
// {value2,
// value1} ? {value2, value1},
// {value4, value3}, {value2,
// value1} duplicate two words
// and insert beneath fourth
// word
final static short swap = 0x5f; // value2, value1 ?
// value1,
// value2 swaps two top words on
// the stack (note that value1
// and value2 must not be double
// or long)
final static short fmul = 0x6a; // value1, value2 ?
// result
// multiplies two floats
final static short dmul = 0x6b; // value1, value2 ?
// result
// multiplies two doubles
final static short idiv = 0x6c; // value1, value2 ?
// result
// divides two integers
final static short ldiv = 0x6d; // value1, value2 ?
// result
// divide two longs
final static short fdiv = 0x6e; // value1, value2 ?
// result
// divides two floats
final static short ddiv = 0x6f; // value1, value2 ?
// result
// divides two doubles
final static short ishr = 0x7a; // value1, value2 ?
// result int
// shift right
final static short lshr = 0x7b; // value1, value2 ?
// result
// bitwise shift right of a long
// value1 by value2 positions
final static short iushr = 0x7c; // value1, value2 ?
// result int
// shift right
final static short lushr = 0x7d; // value1, value2 ?
// result
// bitwise shift right of a long
// value1 by value2 positions,
// unsigned
final static short iand = 0x7e; // value1, value2 ?
// result
// performs a logical and on two
// integers
final static short land = 0x7f; // value1, value2 ?
// result
// bitwise and of two longs
final static short l2d = 0x8a; // value ? result
// converts a
// long to a double
final static short f2i = 0x8b; // value ? result
// converts a
// float to an int
final static short f2l = 0x8c; // value ? result
// converts a
// float to a long
final static short f2d = 0x8d; // value ? result
// converts a
// float to a double
final static short d2i = 0x8e; // value ? result
// converts a
// double to an int
final static short d2l = 0x8f; // value ? result
// converts a
// double to a long
final static short ifne = 0x9a; // branchbyte1,
// branchbyte2
// value ? if value is not 0,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short iflt = 0x9b; // branchbyte1,
// branchbyte2
// value ? if value is less than
// 0, branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short ifge = 0x9c; // branchbyte1,
// branchbyte2
// value ? if value is greater
// than or equal to 0, branch to
// instruction at branchoffset
// (signed short constructed
// from unsigned bytes
// branchbyte1 << 8 +
// branchbyte2)
final static short ifgt = 0x9d; // branchbyte1,
// branchbyte2
// value ? if value is greater
// than 0, branch to instruction
// at branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short ifle = 0x9e; // branchbyte1,
// branchbyte2
// value ? if value is less than
// or equal to 0, branch to
// instruction at branchoffset
// (signed short constructed
// from unsigned bytes
// branchbyte1 << 8 +
// branchbyte2)
final static short if_icmpeq = 0x9f; // branchbyte1,
// branchbyte2
// value1, value2 ? if ints are
// equal, branch to instruction
// at branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short if_icmpne = 0xa0; // branchbyte1,
// branchbyte2
// value1, value2 ? if ints are
// not equal, branch to
// instruction at branchoffset
// (signed short constructed
// from unsigned bytes
// branchbyte1 << 8 +
// branchbyte2)
final static short if_icmplt = 0xa1; // branchbyte1,
// branchbyte2
// value1, value2 ? if value1 is
// less than value2, branch to
// instruction at branchoffset
// (signed short constructed
// from unsigned bytes
// branchbyte1 << 8 +
// branchbyte2)
final static short if_icmpge = 0xa2; // branchbyte1,
// branchbyte2
// value1, value2 ? if value1 is
// greater than or equal to
// value2, branch to instruction
// at branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short if_icmpgt = 0xa3; // branchbyte1,
// branchbyte2
// value1, value2 ? if value1 is
// greater than value2, branch
// to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short if_icmple = 0xa4; // branchbyte1,
// branchbyte2
// value1, value2 ? if value1 is
// less than or equal to value2,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short if_acmpeq = 0xa5; // branchbyte1,
// branchbyte2
// value1, value2 ? if
// references are equal, branch
// to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short if_acmpne = 0xa6; // branchbyte1,
// branchbyte2
// value1, value2 ? if
// references are not equal,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short goto_ = 0xa7; // branchbyte1,
// branchbyte2 [no
// change] goes to another
// instruction at branchoffset
// (signed short constructed
// from unsigned bytes
// branchbyte1 << 8 +
// branchbyte2)
final static short jsr = 0xa8; // branchbyte1,
// branchbyte2 ?
// address jump to subroutine at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2) and place the
// return address on the stack
final static short ret = 0xa9; // index [No change]
// continue
// execution from address taken
// from a local variable #index
// (the asymmetry with jsr is
// intentional)
final static short tableswitch = 0xaa; // [0-3 bytes
// padding],
// defaultbyte1, defaultbyte2,
// defaultbyte3, defaultbyte4,
// lowbyte1, lowbyte2, lowbyte3,
// lowbyte4, highbyte1,
// highbyte2, highbyte3,
// highbyte4, jump offsets...
// index ? continue execution
// from an address in the table
// at offset index
final static short lookupswitch = 0xab; // <0-3 bytes
// padding>,
// defaultbyte1, defaultbyte2,
// defaultbyte3, defaultbyte4,
// npairs1, npairs2, npairs3,
// npairs4, match-offset
// pairs... key ? a target
// address is looked up from a
// table using a key and
// execution continues from the
// instruction at that address
final static short ireturn = 0xac; // value ? [empty]
// returns an
// integer from a method
final static short lreturn = 0xad; // value ? [empty]
// returns a
// long value
final static short freturn = 0xae; // value ? [empty]
// returns a
// float
final static short dreturn = 0xaf; // value ? [empty]
// returns a
// double from a method
final static short areturn = 0xb0; // objectref ?
// [empty]
// returns a
// reference from a method
final static short return_ = 0xb1; // ? [empty] return
// void
// from
// method
final static short getstatic = 0xb2; // index1, index2 ?
// value gets a
// static field value of a
// class, where the field is
// identified by field reference
// in the constant pool index
// (index1 << 8 + index2)
final static short putstatic = 0xb3; // indexbyte1,
// indexbyte2 value
// ? set static field to value
// in a class, where the field
// is identified by a field
// reference index in constant
// pool (indexbyte1 << 8 +
// indexbyte2)
final static short getfield = 0xb4; // index1, index2
// objectref ?
// value gets a field value of
// an object objectref, where
// the field is identified by
// field reference in the
// constant pool index (index1
// << 8 + index2)
final static short putfield = 0xb5; // indexbyte1,
// indexbyte2
// objectref, value ? set field
// to value in an object
// objectref, where the field is
// identified by a field
// reference index in constant
// pool (indexbyte1 << 8 +
// indexbyte2)
final static short invokevirtual = 0xb6; // indexbyte1,
// indexbyte2
// objectref, [arg1, arg2, ...]
// ? invoke virtual method on
// object objectref, where the
// method is identified by
// method reference index in
// constant pool (indexbyte1 <<
// 8 + indexbyte2)
final static short invokespecial = 0xb7; // indexbyte1,
// indexbyte2
// objectref, [arg1, arg2, ...]
// ? invoke instance method on
// object objectref, where the
// method is identified by
// method reference index in
// constant pool (indexbyte1 <<
// 8 + indexbyte2)
final static short invokestatic = 0xb8; // indexbyte1,
// indexbyte2 [arg1,
// arg2, ...] ? invoke a static
// method, where the method is
// identified by method
// reference index in constant
// pool (indexbyte1 << 8 +
// indexbyte2)
final static short invokeinterface = 0xb9; // indexbyte1,
// indexbyte2,
// count, 0 objectref, [arg1,
// arg2, ...] ? invokes an
// interface method on object
// objectref, where the
// interface method is
// identified by method
// reference index in constant
// pool (indexbyte1 << 8 +
// indexbyte2)
final static short invokedynamic = 0xba; // introduced in J7
final static short new_ = 0xbb; // indexbyte1,
// indexbyte2 ?
// objectref creates new object
// of type identified by class
// reference in constant pool
// index (indexbyte1 << 8 +
// indexbyte2)
final static short newarray = 0xbc; // atype count ?
// arrayref
// creates new array with count
// elements of primitive type
// identified by atype
final static short anewarray = 0xbd; // indexbyte1,
// indexbyte2 count
// ? arrayref creates a new
// array of references of length
// count and component type
// identified by the class
// reference index (indexbyte1
// << 8 + indexbyte2) in the
// constant pool
final static short arraylength = 0xbe; // arrayref ? length
// gets the
// length of an array
final static short athrow = 0xbf; // objectref ?
// [empty],
// objectref throws an error or
// exception (notice that the
// rest of the stack is cleared,
// leaving only a reference to
// the Throwable)
final static short checkcast = 0xc0; // indexbyte1,
// indexbyte2
// objectref ? objectref checks
// whether an objectref is of a
// certain type, the class
// reference of which is in the
// constant pool at index
// (indexbyte1 << 8 +
// indexbyte2)
final static short instanceof_ = 0xc1; // indexbyte1,
// indexbyte2
// objectref ? result determines
// if an object objectref is of
// a given type, identified by
// class reference index in
// constant pool (indexbyte1 <<
// 8 + indexbyte2)
final static short monitorenter = 0xc2; // objectref ? enter
// monitor for
// object ("grab the lock" -
// start of synchronized()
// section)
final static short monitorexit = 0xc3; // objectref ? exit
// monitor for
// object ("release the lock" -
// end of synchronized()
// section)
final static short wide = 0xc4; // opcode,
// indexbyte1,
// indexbyte2
final static short multianewarray = 0xc5; // indexbyte1,
// indexbyte2,
// dimensions count1,
// [count2,...] ? arrayref
// create a new array of
// dimensions dimensions with
// elements of type identified
// by class reference in
// constant pool index
// (indexbyte1 << 8 +
// indexbyte2); the sizes of
// each dimension is identified
// by count1, [count2, etc]
final static short ifnull = 0xc6; // branchbyte1,
// branchbyte2
// value ? if value is null,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short ifnonnull = 0xc7; // branchbyte1,
// branchbyte2
// value ? if value is not null,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned
// bytes branchbyte1 << 8 +
// branchbyte2)
final static short goto_w = 0xc8; // branchbyte1,
// branchbyte2,
// branchbyte3, branchbyte4 [no
// change] goes to another
// instruction at branchoffset
// (signed int constructed from
// unsigned bytes branchbyte1 <<
// 24 + branchbyte2 << 16 +
// branchbyte3 << 8 +
// branchbyte4)
final static short jsr_w = 0xc9; // branchbyte1,
// branchbyte2,
// branchbyte3, branchbyte4 ?
// address jump to subroutine at
// branchoffset (signed int
// constructed from unsigned
// bytes branchbyte1 << 24 +
// branchbyte2 << 16 +
// branchbyte3 << 8 +
// branchbyte4) and place the
// return address on the stack
final static short breakpoint = 0xca; // reserved for
// breakpoints in
// Java debuggers; should not
// appear in any class file
final static short impdep1 = 0xfe; // reserved for
// implementation-dependent
// operations within debuggers;
// should not appear in any
// class file
final static short impdep2 = 0xff; // reserved for
// implementation-dependent
// operations within debuggers;
// should not appear in any
// class file
final static byte OFFSETS[] = new byte[256];
static {
OFFSETS[bipush] = 1; // byte ? value pushes a byte onto the
// stack as an integer value
OFFSETS[sipush] = 2; // byte1, byte2 ? value pushes a signed
// integer (byte1 << 8 + byte2) onto the
// stack
OFFSETS[ldc] = 1; // index ? value pushes a constant
// #index from a constant pool (String,
// int, float or class type) onto the
// stack
OFFSETS[ldc_w] = 2; // indexbyte1, indexbyte2 ? value pushes
// a constant #index from a constant
// pool (String, int, float or class
// type) onto the stack (wide index is
// constructed as indexbyte1 << 8 +
// indexbyte2)
OFFSETS[ldc2_w] = 2; // indexbyte1, indexbyte2 ? value pushes
// a constant #index from a constant
// pool (double or long) onto the stack
// (wide index is constructed as
// indexbyte1 << 8 + indexbyte2)
OFFSETS[iload] = 1; // index ? value loads an int value from
// a variable #index
OFFSETS[lload] = 1; // index ? value load a long value from
// a local variable #index
OFFSETS[fload] = 1; // index ? value loads a float value
// from a local variable #index
OFFSETS[dload] = 1; // index ? value loads a double value
// from a local variable #index
OFFSETS[aload] = 1; // index ? objectref loads a reference
// onto the stack from a local variable
// #index
OFFSETS[istore] = 1; // index value ? store int value into
// variable #index
OFFSETS[lstore] = 1; // index value ? store a long value in a
// local variable #index
OFFSETS[fstore] = 1; // index value ? stores a float value
// into a local variable #index
OFFSETS[dstore] = 1; // index value ? stores a double value
// into a local variable #index
OFFSETS[iinc] = 2; // index, const [No change] increment
// local variable #index by signed byte
// const
OFFSETS[ifeq] = 2; // branchbyte1, branchbyte2 value ? if
// value is 0, branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[astore] = 1; // index objectref ? stores a reference
// into a local variable #index
OFFSETS[ifne] = 2; // branchbyte1, branchbyte2 value ? if
// value is not 0, branch to instruction
// at branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[iflt] = 2; // branchbyte1, branchbyte2 value ? if
// value is less than 0, branch to
// instruction at branchoffset (signed
// short constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[ifge] = 2; // branchbyte1, branchbyte2 value ? if
// value is greater than or equal to 0,
// branch to instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[ifgt] = 2; // branchbyte1, branchbyte2 value ? if
// value is greater than 0, branch to
// instruction at branchoffset (signed
// short constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[ifle] = 2; // branchbyte1, branchbyte2 value ? if
// value is less than or equal to 0,
// branch to instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[if_icmpeq] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if ints are equal,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[if_icmpne] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if ints are not equal,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[if_icmplt] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if value1 is less than
// value2, branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[if_icmpge] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if value1 is greater
// than or equal to value2, branch
// to instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[if_icmpgt] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if value1 is greater
// than value2, branch to
// instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[if_icmple] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if value1 is less than
// or equal to value2, branch to
// instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[if_acmpeq] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if references are equal,
// branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[if_acmpne] = 2; // branchbyte1, branchbyte2 value1,
// value2 ? if references are not
// equal, branch to instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[goto_] = 2; // branchbyte1, branchbyte2 [no change]
// goes to another instruction at
// branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[jsr] = 2; // branchbyte1, branchbyte2 ? address
// jump to subroutine at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2) and place the return
// address on the stack
OFFSETS[ret] = 1; // index [No change] continue execution
// from address taken from a local
// variable #index (the asymmetry with
// jsr is intentional)
OFFSETS[tableswitch] = -1; // [0-3 bytes padding],
// defaultbyte1, defaultbyte2,
// defaultbyte3, defaultbyte4,
// lowbyte1, lowbyte2, lowbyte3,
// lowbyte4, highbyte1,
// highbyte2, highbyte3,
// highbyte4, jump offsets...
// index ? continue execution
// from an address in the table
// at offset index
OFFSETS[lookupswitch] = -1; // <0-3 bytes padding>,
// defaultbyte1, defaultbyte2,
// defaultbyte3, defaultbyte4,
// npairs1, npairs2, npairs3,
// npairs4, match-offset
// pairs... key ? a target
// address is looked up from a
// table using a key and
// execution continues from the
// instruction at that address
OFFSETS[getstatic] = 2; // index1, index2 ? value gets a
// static field value of a class,
// where the field is identified by
// field reference in the constant
// pool index (index1 << 8 + index2)
OFFSETS[putstatic] = 2; // indexbyte1, indexbyte2 value ?
// set static field to value in a
// class, where the field is
// identified by a field reference
// index in constant pool
// (indexbyte1 << 8 + indexbyte2)
OFFSETS[getfield] = 2; // index1, index2 objectref ? value
// gets a field value of an object
// objectref, where the field is
// identified by field reference in
// the constant pool index (index1
// << 8 + index2)
OFFSETS[putfield] = 2; // indexbyte1, indexbyte2 objectref,
// value ? set field to value in an
// object objectref, where the field
// is identified by a field
// reference index in constant pool
// (indexbyte1 << 8 + indexbyte2)
OFFSETS[invokevirtual] = 2; // indexbyte1, indexbyte2
// objectref, [arg1, arg2, ...]
// ? invoke virtual method on
// object objectref, where the
// method is identified by
// method reference index in
// constant pool (indexbyte1 <<
// 8 + indexbyte2)
OFFSETS[invokespecial] = 2; // indexbyte1, indexbyte2
// objectref, [arg1, arg2, ...]
// ? invoke instance method on
// object objectref, where the
// method is identified by
// method reference index in
// constant pool (indexbyte1 <<
// 8 + indexbyte2)
OFFSETS[invokestatic] = 2; // indexbyte1, indexbyte2 [arg1,
// arg2, ...] ? invoke a static
// method, where the method is
// identified by method
// reference index in constant
// pool (indexbyte1 << 8 +
// indexbyte2)
OFFSETS[invokeinterface] = 2; // indexbyte1, indexbyte2,
// count, 0 objectref,
// [arg1, arg2, ...] ?
// invokes an interface
// method on object
// objectref, where the
// interface method is
// identified by method
// reference index in
// constant pool (indexbyte1
// << 8 + indexbyte2)
OFFSETS[invokedynamic] = 4; // 4: indexbyte1, indexbyte2, 0, 0
OFFSETS[new_] = 2; // indexbyte1, indexbyte2 ? objectref
// creates new object of type identified
// by class reference in constant pool
// index (indexbyte1 << 8 + indexbyte2)
OFFSETS[newarray] = 1; // atype count ? arrayref creates
// new array with count elements of
// primitive type identified by
// atype
OFFSETS[anewarray] = 2; // indexbyte1, indexbyte2 count ?
// arrayref creates a new array of
// references of length count and
// component type identified by the
// class reference index (indexbyte1
// << 8 + indexbyte2) in the
// constant pool
OFFSETS[checkcast] = 2; // indexbyte1, indexbyte2 objectref
// ? objectref checks whether an
// objectref is of a certain type,
// the class reference of which is
// in the constant pool at index
// (indexbyte1 << 8 + indexbyte2)
OFFSETS[instanceof_] = 2; // indexbyte1, indexbyte2 objectref
// ? result determines if an object
// objectref is of a given type,
// identified by class reference
// index in constant pool
// (indexbyte1 << 8 + indexbyte2)
OFFSETS[wide] = 3; // opcode, indexbyte1, indexbyte2
OFFSETS[multianewarray] = 3; // indexbyte1, indexbyte2,
// dimensions count1,
// [count2,...] ? arrayref
// create a new array of
// dimensions dimensions with
// elements of type identified
// by class reference in
// constant pool index
// (indexbyte1 << 8 +
// indexbyte2); the sizes of
// each dimension is identified
// by count1, [count2, etc]
OFFSETS[ifnull] = 2; // branchbyte1, branchbyte2 value ? if
// value is null, branch to instruction
// at branchoffset (signed short
// constructed from unsigned bytes
// branchbyte1 << 8 + branchbyte2)
OFFSETS[ifnonnull] = 2; // branchbyte1, branchbyte2 value ?
// if value is not null, branch to
// instruction at branchoffset
// (signed short constructed from
// unsigned bytes branchbyte1 << 8 +
// branchbyte2)
OFFSETS[goto_w] = 4; // branchbyte1, branchbyte2,
// branchbyte3, branchbyte4 [no change]
// goes to another instruction at
// branchoffset (signed int constructed
// from unsigned bytes branchbyte1 << 24
// + branchbyte2 << 16 + branchbyte3 <<
// 8 + branchbyte4)
OFFSETS[jsr_w] = 4; // branchbyte1, branchbyte2,
// branchbyte3, branchbyte4 ? address
// jump to subroutine at branchoffset
// (signed int constructed from unsigned
// bytes branchbyte1 << 24 + branchbyte2
// << 16 + branchbyte3 << 8 +
// branchbyte4) and place the return
// address on the stack
}
}