com.shakelang.shake.bytecode.conventions/com.shakelang.shake.bytecode.interpreter/Opcodes

Opcodes

object Opcodes(source)

Properties

BADD

const val BADD: Byte = 16

Add two bytes on top of the stack (the first 2 bytes)

BALOAD

const val BALOAD: Byte

Load a byte from an array

BAND

const val BAND: Byte = 80

Bitwise AND the two bytes on top of the stack

BASTORE

const val BASTORE: Byte

Store a byte in an array

BCMP

const val BCMP: Byte = 112

Compare two bytes

BDEC

const val BDEC: Byte = 74

Decrement a byte

BDIV

const val BDIV: Byte = 42

Divide two bytes on top of the stack (the first 2 bytes)

BDUP

const val BDUP: Byte

Duplicate the top element of the stack

BINC

const val BINC: Byte = 68

Increment a byte

BLOAD

const val BLOAD: Byte = 5

Load a byte from a local variable onto the stack

BMOD

const val BMOD: Byte = 52

Modulo two bytes on top of the stack (the first 2 bytes)

BMUL

const val BMUL: Byte = 32

Multiply two bytes on top of the stack (the first 2 bytes)

BNEG

const val BNEG: Byte = 62

Negate the byte on top of the stack

BNOT

const val BNOT: Byte = 92

Bitwise NOT the top byte on the stack

BOR

const val BOR: Byte = 84

Bitwise OR two bytes on top of the stack

BPOP

const val BPOP: Byte

Pop the top element of the stack

BPUSH

const val BPUSH: Byte = 1

Push a byte onto the stack

BRET

const val BRET: Byte

Store a byte as return value

BSHL

const val BSHL: Byte = 96

Bitwise shift left a byte (the top byte is the amount, the second byte is the value to shift)

BSHR

const val BSHR: Byte = 100

Bitwise shift right a byte (the top byte is the amount, the second byte is the value to shift)

BSHRU

const val BSHRU: Byte = 104

Bitwise shift right unsigned a byte (the top byte is the amount, the second byte is the value to shift)

BSTORE

const val BSTORE: Byte = 9

Store a byte from the stack into a local variable

BSUB

const val BSUB: Byte = 22

Subtract two bytes on top of the stack (the first 2 bytes)

BXOR

const val BXOR: Byte = 88

Bitwise XOR two bytes on top of the stack

CEQ

const val CEQ: Byte = 124

Compare result is equal

CGE

const val CGE: Byte = 126

Compare result is greater than or equal

CGT

const val CGT: Byte = 127

Compare result is greater than

CLE

const val CLE: Byte = 123

Compare result is less than or equal

CLT

const val CLT: Byte = 122

Compare result is less than

CNE

const val CNE: Byte = 125

Compare result is not equal

DADD

const val DADD: Byte = 21

Add two doubles on top of the stack (the first 16 bytes)

DCMP

const val DCMP: Byte = 117

Compare two doubles

DDEC

const val DDEC: Byte = 79

Decrement a double

DDIV

const val DDIV: Byte = 51

Divide two doubles on top of the stack (the first 16 bytes)

DINC

const val DINC: Byte = 73

Increment a double

DMOD

const val DMOD: Byte = 61

Modulo two doubles on top of the stack (the first 16 bytes)

DMUL

const val DMUL: Byte = 41

Multiply two doubles on top of the stack (the first 16 bytes)

DNEG

const val DNEG: Byte = 67

Negate the double on top of the stack

DSUB

const val DSUB: Byte = 31

Subtract two doubles on top of the stack (the first 16 bytes)

FADD

const val FADD: Byte = 20

Add two floats on top of the stack (the first 8 bytes)

FCMP

const val FCMP: Byte = 116

Compare two floats

FDEC

const val FDEC: Byte = 78

Decrement a float

FDIV

const val FDIV: Byte = 50

Divide two floats on top of the stack (the first 8 bytes)

FINC

const val FINC: Byte = 72

Increment a float

FMOD

const val FMOD: Byte = 60

Modulo two floats on top of the stack (the first 8 bytes)

FMUL

const val FMUL: Byte = 40

Multiply two floats on top of the stack (the first 8 bytes)

FNEG

const val FNEG: Byte = 66

Negate the float on top of the stack

FSUB

const val FSUB: Byte = 30

Subtract two floats on top of the stack (the first 8 bytes)

IADD

const val IADD: Byte = 18

Add two ints on top of the stack (the first 8 bytes)

IALOAD

const val IALOAD: Byte

Load an int from an array

IAND

const val IAND: Byte = 82

Bitwise AND two ints (the first 8 bytes)

IASTORE

const val IASTORE: Byte

Store an int in an array

ICMP

const val ICMP: Byte = 114

Compare two ints

IDEC

const val IDEC: Byte = 76

Decrement an int

IDIV

const val IDIV: Byte = 44

Divide two ints on top of the stack (the first 8 bytes)

IDUP

const val IDUP: Byte

Duplicate the top 4 elements of the stack

IINC

const val IINC: Byte = 70

Increment an int

ILOAD

const val ILOAD: Byte = 7

Load an int from a local variable onto the stack

IMOD

const val IMOD: Byte = 54

Modulo two ints on top of the stack (the first 8 bytes)

IMUL

const val IMUL: Byte = 34

Multiply two ints on top of the stack (the first 8 bytes)

INEG

const val INEG: Byte = 64

Negate the int on top of the stack

INOT

const val INOT: Byte = 94

Bitwise NOT the top int on the stack

INVOKE_STATIC

const val INVOKE_STATIC: Byte

Invoke-Static instruction

INVOKE_VIRTUAL

const val INVOKE_VIRTUAL: Byte

Invoke instance instruction

IOR

const val IOR: Byte = 86

Bitwise OR two ints (the first 8 bytes)

IPOP

const val IPOP: Byte

Pop the top 4 elements of the stack

IPUSH

const val IPUSH: Byte = 3

Push an int onto the stack

IRET

const val IRET: Byte

Store an int as return value

ISHL

const val ISHL: Byte = 98

Bitwise shift left an int (the top byte is the amount, the second int is the value to shift)

ISHR

const val ISHR: Byte = 102

Bitwise shift right an int (the top byte is the amount, the second int is the value to shift)

ISHRU

const val ISHRU: Byte = 106

Bitwise shift right unsigned an int (the top byte is the amount, the second int is the value to shift)

ISTORE

const val ISTORE: Byte = 11

Store an int from the stack into a local variable

ISUB

const val ISUB: Byte = 24

Subtract two ints on top of the stack (the first 8 bytes)

IXOR

const val IXOR: Byte = 90

Bitwise XOR two ints (the first 8 bytes)

const val JE: Byte

Jump to an address if the top two values are equal (takes the top byte value and jumps if it is 1)

const val JG: Byte

Jump to an address if the top two values are greater than (takes the top byte value and jumps if it is 0)

JGE

const val JGE: Byte

Jump to an address if the top two values are greater than or equal (takes the top byte value and jumps if it is 0 or 1)

const val JL: Byte

Jump to an address if the top two values are less than (takes the top byte value and jumps if it is 2)

JLE

const val JLE: Byte

Jump to an address if the top two values are less than or equal (takes the top byte value and jumps if it is 1 or 2)

JMP

const val JMP: Byte

Jump to an address

JNE

const val JNE: Byte

Jump to an address if the top two values are not equal (takes the top byte value and jumps if it is not 1)

JNZ

const val JNZ: Byte

Jump to an address if there is not a zero on top of the stack (takes the top byte value and jumps if it is 1)

const val JZ: Byte

Jump to an address if there is a zero on top of the stack (takes the top byte value and jumps if it is 0)

LADD

const val LADD: Byte = 19

Add two longs on top of the stack (the first 16 bytes)

LALOAD

const val LALOAD: Byte

Load a long from an array

LAND

const val LAND: Byte = 83

Bitwise AND two longs (the first 16 bytes)

LASTORE

const val LASTORE: Byte

Store a long in an array

LCMP

const val LCMP: Byte = 115

Compare two longs

LDEC

const val LDEC: Byte = 77

Decrement a long

LDIV

const val LDIV: Byte = 45

Divide two longs on top of the stack (the first 16 bytes)

LDUP

const val LDUP: Byte

Duplicate the top 8 elements of the stack

LINC

const val LINC: Byte = 71

Increment a long

LLOAD

const val LLOAD: Byte = 8

Load a long from a local variable onto the stack

LMOD

const val LMOD: Byte = 55

Modulo two longs on top of the stack (the first 16 bytes)

LMUL

const val LMUL: Byte = 35

Multiply two longs on top of the stack (the first 16 bytes)

LNEG

const val LNEG: Byte = 65

Negate the long on top of the stack

LNOT

const val LNOT: Byte = 95

Bitwise NOT the top long on the stack

LOAD_STATIC

const val LOAD_STATIC: Byte

Load static field instruction

LOAD_VIRTUAL

const val LOAD_VIRTUAL: Byte

Load instance field instruction

LOR

const val LOR: Byte = 87

Bitwise OR two longs (the first 16 bytes)

LPOP

const val LPOP: Byte

Pop the top 8 elements of the stack

LPUSH

const val LPUSH: Byte = 4

Push a long onto the stack

LRET

const val LRET: Byte

Store a long as return value

LSHL

const val LSHL: Byte = 99

Bitwise shift left a long (the top byte is the amount, the second long is the value to shift)

LSHR

const val LSHR: Byte = 103

Bitwise shift right a long (the top byte is the amount, the second long is the value to shift)

LSHRU

const val LSHRU: Byte = 107

Bitwise shift right unsigned a long (the top byte is the amount, the second long is the value to shift)

LSTORE

const val LSTORE: Byte = 12

Store a long from the stack into a local variable

LSUB

const val LSUB: Byte = 25

Subtract two longs on top of the stack (the first 16 bytes)

LXOR

const val LXOR: Byte = 91

Bitwise XOR two longs (the first 16 bytes)

NEW_ARR

const val NEW_ARR: Byte

Construct a new array

NEW_OBJ

const val NEW_OBJ: Byte

Construct a new object from a class

NOP

const val NOP: Byte = 0

No instruction

PCAST

const val PCAST: Byte

Primitive cast operation. The top element of the stack will be cast.

RET

const val RET: Byte

Return from a function

SADD

const val SADD: Byte = 17

Add two shorts on top of the stack (the first 4 bytes)

SALOAD

const val SALOAD: Byte

Load a short from an array

SAND

const val SAND: Byte = 81

Bitwise AND two shorts (the first 4 bytes)

SASTORE

const val SASTORE: Byte

Store a short in an array

SCMP

const val SCMP: Byte = 113

Compare two shorts

SDEC

const val SDEC: Byte = 75

Decrement a short

SDIV

const val SDIV: Byte = 43

Divide two shorts on top of the stack (the first 4 bytes)

SDUP

const val SDUP: Byte

Duplicate the top 2 elements of the stack

SINC

const val SINC: Byte = 69

Increment a short

SLOAD

const val SLOAD: Byte = 6

Load a short from a local variable onto the stack

SMOD

const val SMOD: Byte = 53

Modulo two shorts on top of the stack (the first 4 bytes)

SMUL

const val SMUL: Byte = 33

Multiply two shorts on top of the stack (the first 4 bytes)

SNEG

const val SNEG: Byte = 63

Negate the short on top of the stack

SNOT

const val SNOT: Byte = 93

Bitwise NOT the top short on the stack

SOR

const val SOR: Byte = 85

Bitwise OR two shorts (the first 4 bytes)

SPOP

const val SPOP: Byte

Pop the top 2 elements of the stack

SPUSH

const val SPUSH: Byte = 2

Push a short onto the stack

SRET

const val SRET: Byte

Store a short as return value

SSHL

const val SSHL: Byte = 97

Bitwise shift left a short (the top byte is the amount, the second short is the value to shift)

SSHR

const val SSHR: Byte = 101

Bitwise shift right a short (the top byte is the amount, the second short is the value to shift)

SSHRU

const val SSHRU: Byte = 105

Bitwise shift right unsigned a short (the top byte is the amount, the second short is the value to shift)

SSTORE

const val SSTORE: Byte = 10

Store a short from the stack into a local variable

SSUB

const val SSUB: Byte = 23

Subtract two shorts on top of the stack (the first 4 bytes)

STORE_STATIC

const val STORE_STATIC: Byte

Store a field in a class

STORE_VIRTUAL

const val STORE_VIRTUAL: Byte

Store a field in an instance

SXOR

const val SXOR: Byte = 89

Bitwise XOR two shorts (the first 4 bytes)

THROW

const val THROW: Byte

Throw an exception

UBCMP

const val UBCMP: Byte = 118

Compare two unsigned bytes

UBDIV

const val UBDIV: Byte = 46

Divide two unsigned bytes on top of the stack (the first 2 bytes)

UBMOD

const val UBMOD: Byte = 56

Modulo two unsigned bytes on top of the stack (the first 2 bytes)

UBMUL

const val UBMUL: Byte = 36

Multiply two unsigned bytes on top of the stack (the first 2 bytes)

UBSUB

const val UBSUB: Byte = 26

Subtract two unsigned bytes on top of the stack (the first 2 bytes)

UICMP

const val UICMP: Byte = 120

Compare two unsigned ints

UIDIV

const val UIDIV: Byte = 48

Divide two unsigned ints on top of the stack (the first 8 bytes)

UIMOD

const val UIMOD: Byte = 58

Modulo two unsigned ints on top of the stack (the first 8 bytes)

UIMUL

const val UIMUL: Byte = 38

Multiply two unsigned ints on top of the stack (the first 8 bytes)

UISUB

const val UISUB: Byte = 28

Subtract two unsigned ints on top of the stack (the first 8 bytes)

ULCMP

const val ULCMP: Byte = 121

Compare two unsigned longs

ULDIV

const val ULDIV: Byte = 49

Divide two unsigned longs on top of the stack (the first 16 bytes)

ULMOD

const val ULMOD: Byte = 59

Modulo two unsigned longs on top of the stack (the first 16 bytes)

ULMUL

const val ULMUL: Byte = 39

Multiply two unsigned longs on top of the stack (the first 16 bytes)

ULSUB

const val ULSUB: Byte = 29

Subtract two unsigned longs on top of the stack (the first 16 bytes)

USCMP

const val USCMP: Byte = 119

Compare two unsigned shorts

USDIV

const val USDIV: Byte = 47

Divide two unsigned shorts on top of the stack (the first 4 bytes)

USMOD

const val USMOD: Byte = 57

Modulo two unsigned shorts on top of the stack (the first 4 bytes)

USMUL

const val USMUL: Byte = 37

Multiply two unsigned shorts on top of the stack (the first 4 bytes)

USSUB

const val USSUB: Byte = 27

Subtract two unsigned shorts on top of the stack (the first 4 bytes)