TrueCloudLab/neo-go
8
0
Fork 0
mirror of https://github.com/nspcc-dev/neo-go.git synced 2024-11-30 09:33:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
neo-go/pkg/vm/opcode/opcode.go

238 lines
5.5 KiB
Go
Raw Normal View History

vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
package opcode
core: drop OLDPUSH1, it's no longer needed Fixes #927.
2020-06-05 10:04:20 +00:00
//go:generate stringer -type=Opcode -linecomment
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
// Opcode represents a single operation code for the NEO virtual machine.
type Opcode byte
// Viable list of supported instruction constants.
const (
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Constants.
vm: implement new PUSH opcodes
2020-04-21 13:45:48 +00:00
PUSHINT8 Opcode = 0x00
PUSHINT16 Opcode = 0x01
PUSHINT32 Opcode = 0x02
PUSHINT64 Opcode = 0x03
PUSHINT128 Opcode = 0x04
PUSHINT256 Opcode = 0x05
vm: implement PUSHA/CALLA opcodes
2020-05-06 13:55:30 +00:00
PUSHA Opcode = 0x0A
vm: implement new PUSH opcodes
2020-04-21 13:45:48 +00:00
PUSHNULL Opcode = 0x0B
PUSHDATA1 Opcode = 0x0C
PUSHDATA2 Opcode = 0x0D
PUSHDATA4 Opcode = 0x0E
PUSHM1 Opcode = 0x0F
PUSH0 Opcode = 0x10
PUSHF Opcode = PUSH0
PUSH1 Opcode = 0x11
PUSHT Opcode = PUSH1
PUSH2 Opcode = 0x12
PUSH3 Opcode = 0x13
PUSH4 Opcode = 0x14
PUSH5 Opcode = 0x15
PUSH6 Opcode = 0x16
PUSH7 Opcode = 0x17
PUSH8 Opcode = 0x18
PUSH9 Opcode = 0x19
PUSH10 Opcode = 0x1A
PUSH11 Opcode = 0x1B
PUSH12 Opcode = 0x1C
PUSH13 Opcode = 0x1D
PUSH14 Opcode = 0x1E
PUSH15 Opcode = 0x1F
PUSH16 Opcode = 0x20
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Flow control.
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
NOP Opcode = 0x21
JMP Opcode = 0x22
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPL Opcode = 0x23 // JMP_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPIF Opcode = 0x24
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPIFL Opcode = 0x25 // JMPIF_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPIFNOT Opcode = 0x26
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPIFNOTL Opcode = 0x27 // JMPIFNOT_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPEQ Opcode = 0x28
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPEQL Opcode = 0x29 // JMPEQ_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPNE Opcode = 0x2A
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPNEL Opcode = 0x2B // JMPNE_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPGT Opcode = 0x2C
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPGTL Opcode = 0x2D // JMPGT_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPGE Opcode = 0x2E
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPGEL Opcode = 0x2F // JMPGE_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPLT Opcode = 0x30
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPLTL Opcode = 0x31 // JMPLT_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
JMPLE Opcode = 0x32
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
JMPLEL Opcode = 0x33 // JMPLE_L
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
CALL Opcode = 0x34
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
CALLL Opcode = 0x35 // CALL_L
vm: implement PUSHA/CALLA opcodes
2020-05-06 13:55:30 +00:00
CALLA Opcode = 0x36
opcode: add CALLT opcode, move ABORT/ASSERT Refs. #1644. Hash compatibility test temporarily disabled, to be enabled when it's up to date with current C# master.
2021-01-15 21:16:42 +00:00
CALLT Opcode = 0x37
vm: implement new JMP* and CALL* opcodes In compiler JMP*_L opcodes are always used, as this requires less effort.
2020-04-23 08:56:36 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Exceptions.
opcode: add CALLT opcode, move ABORT/ASSERT Refs. #1644. Hash compatibility test temporarily disabled, to be enabled when it's up to date with current C# master.
2021-01-15 21:16:42 +00:00
ABORT Opcode = 0x38
ASSERT Opcode = 0x39
vm: support exceptions Implement 3 new instructions: TRY,ENDTRY,ENDFINALLY. 1. TRY marks the start of the block where exceptions are catched. It has 2 arguments which are relative offsets of exception handler and the end of the whole try/catch construction. 2. ENDTRY denotes either end of try or catch block. 3. ENDFINALLY denotes end of finally block which is executed irregardless of whether an exception has occured.
2020-07-22 09:05:46 +00:00
THROW Opcode = 0x3A
TRY Opcode = 0x3B
TRYL Opcode = 0x3C // TRY_L
ENDTRY Opcode = 0x3D
ENDTRYL Opcode = 0x3E // ENDTRY_L
ENDFINALLY Opcode = 0x3F
vm: implement ASSERT/ABORT opcodes Rename THROWIFNOT to ASSERT, add ABORT opcode. ABORT cannot be caught, but the implementation should be postponed until exception handling is implemented.
2020-05-06 12:54:18 +00:00
vm: move RET and SYSCALL opcodes
2020-05-07 10:23:05 +00:00
RET Opcode = 0x40
SYSCALL Opcode = 0x41
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Stack.
vm: implement CLEAR opcode
2020-05-06 08:32:22 +00:00
DEPTH Opcode = 0x43
DROP Opcode = 0x45
NIP Opcode = 0x46
XDROP Opcode = 0x48
CLEAR Opcode = 0x49
vm: reorder stack opcodes Leave *ALTSTACK opcodes for now as they are needed in compiler while slot opcodes are not yet here.
2020-05-06 08:19:58 +00:00
DUP Opcode = 0x4A
OVER Opcode = 0x4B
PICK Opcode = 0x4D
TUCK Opcode = 0x4E
SWAP Opcode = 0x50
ROT Opcode = 0x51
ROLL Opcode = 0x52
vm: implement REVERSE* opcodes Use new opcodes in the compiler instead of XSWAP/ROLL.
2020-05-06 09:12:29 +00:00
REVERSE3 Opcode = 0x53
REVERSE4 Opcode = 0x54
REVERSEN Opcode = 0x55
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Slots.
vm: implement slot-related opcodes 1. Slot is a new mechanism for storing variables during execution which is more convenient than alt.stack. This commit implements support for slot opcodes in both vm and compiler. 2. Remove old alt.stack opcodes. 3. Do not process globals at the start of every function, but instead load them single time at main.
2020-05-07 08:54:35 +00:00
INITSSLOT Opcode = 0x56
INITSLOT Opcode = 0x57
LDSFLD0 Opcode = 0x58
LDSFLD1 Opcode = 0x59
LDSFLD2 Opcode = 0x5A
LDSFLD3 Opcode = 0x5B
LDSFLD4 Opcode = 0x5C
LDSFLD5 Opcode = 0x5D
LDSFLD6 Opcode = 0x5E
LDSFLD Opcode = 0x5F
STSFLD0 Opcode = 0x60
STSFLD1 Opcode = 0x61
STSFLD2 Opcode = 0x62
STSFLD3 Opcode = 0x63
STSFLD4 Opcode = 0x64
STSFLD5 Opcode = 0x65
STSFLD6 Opcode = 0x66
STSFLD Opcode = 0x67
LDLOC0 Opcode = 0x68
LDLOC1 Opcode = 0x69
LDLOC2 Opcode = 0x6A
LDLOC3 Opcode = 0x6B
LDLOC4 Opcode = 0x6C
LDLOC5 Opcode = 0x6D
LDLOC6 Opcode = 0x6E
LDLOC Opcode = 0x6F
STLOC0 Opcode = 0x70
STLOC1 Opcode = 0x71
STLOC2 Opcode = 0x72
STLOC3 Opcode = 0x73
STLOC4 Opcode = 0x74
STLOC5 Opcode = 0x75
STLOC6 Opcode = 0x76
STLOC Opcode = 0x77
LDARG0 Opcode = 0x78
LDARG1 Opcode = 0x79
LDARG2 Opcode = 0x7A
LDARG3 Opcode = 0x7B
LDARG4 Opcode = 0x7C
LDARG5 Opcode = 0x7D
LDARG6 Opcode = 0x7E
LDARG Opcode = 0x7F
STARG0 Opcode = 0x80
STARG1 Opcode = 0x81
STARG2 Opcode = 0x82
STARG3 Opcode = 0x83
STARG4 Opcode = 0x84
STARG5 Opcode = 0x85
STARG6 Opcode = 0x86
STARG Opcode = 0x87
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Splice.
vm: implement NEWBUFFER opcode
2020-05-12 11:53:17 +00:00
NEWBUFFER Opcode = 0x88
vm: implement MEMCPY opcode MEMCPY copies byte-slice to a destination buffer.
2020-05-12 11:55:31 +00:00
MEMCPY Opcode = 0x89
vm: implement NEWBUFFER opcode
2020-05-12 11:53:17 +00:00
CAT Opcode = 0x8B
SUBSTR Opcode = 0x8C
LEFT Opcode = 0x8D
RIGHT Opcode = 0x8E
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Bitwise logic.
vm: implement NOTEQUAL opcode
2020-04-30 07:52:29 +00:00
INVERT Opcode = 0x90
AND Opcode = 0x91
OR Opcode = 0x92
XOR Opcode = 0x93
EQUAL Opcode = 0x97
NOTEQUAL Opcode = 0x98
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Arithmetic.
vm: reorder arithmetic opcodes
2020-04-28 13:05:11 +00:00
SIGN Opcode = 0x99
ABS Opcode = 0x9A
NEGATE Opcode = 0x9B
INC Opcode = 0x9C
DEC Opcode = 0x9D
ADD Opcode = 0x9E
SUB Opcode = 0x9F
MUL Opcode = 0xA0
DIV Opcode = 0xA1
MOD Opcode = 0xA2
vm: implement POW opcode
2021-03-01 09:22:22 +00:00
POW Opcode = 0xA3
vm: implement SQRT opcode
2021-03-01 09:26:15 +00:00
SQRT Opcode = 0xA4
vm: reorder arithmetic opcodes
2020-04-28 13:05:11 +00:00
SHL Opcode = 0xA8
SHR Opcode = 0xA9
NOT Opcode = 0xAA
BOOLAND Opcode = 0xAB
BOOLOR Opcode = 0xAC
NZ Opcode = 0xB1
NUMEQUAL Opcode = 0xB3
NUMNOTEQUAL Opcode = 0xB4
LT Opcode = 0xB5
opcode: fix GTE, LTE string representations
2021-04-29 11:34:23 +00:00
LE Opcode = 0xB6
vm: reorder arithmetic opcodes
2020-04-28 13:05:11 +00:00
GT Opcode = 0xB7
opcode: fix GTE, LTE string representations
2021-04-29 11:34:23 +00:00
GE Opcode = 0xB8
vm: reorder arithmetic opcodes
2020-04-28 13:05:11 +00:00
MIN Opcode = 0xB9
MAX Opcode = 0xBA
WITHIN Opcode = 0xBB
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Advanced data structures (arrays, structures, maps).
vm: implement NEWARRAYT opcode
2020-04-24 10:48:19 +00:00
PACK Opcode = 0xC0
UNPACK Opcode = 0xC1
NEWARRAY0 Opcode = 0xC2
NEWARRAY Opcode = 0xC3
opcode: use underscored names in String()
2020-05-21 09:54:50 +00:00
NEWARRAYT Opcode = 0xC4 // NEWARRAY_T
vm: implement NEWARRAY0 and NEWSTRUCT0 opcodes
2020-04-24 09:31:59 +00:00
NEWSTRUCT0 Opcode = 0xC5
vm: reorder Array/Map opcodes Also SIZE can be used for both Arrays/Maps and ByteArrays.
2020-04-24 09:24:08 +00:00
NEWSTRUCT Opcode = 0xC6
NEWMAP Opcode = 0xC8
SIZE Opcode = 0xCA
HASKEY Opcode = 0xCB
KEYS Opcode = 0xCC
VALUES Opcode = 0xCD
PICKITEM Opcode = 0xCE
APPEND Opcode = 0xCF
SETITEM Opcode = 0xD0
REVERSEITEMS Opcode = 0xD1
REMOVE Opcode = 0xD2
vm: implement CLEARITEMS opcode
2020-04-24 10:02:38 +00:00
CLEARITEMS Opcode = 0xD3
vm: implement POPITEM opcode
2021-01-18 13:15:04 +00:00
POPITEM Opcode = 0xD4
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
*: enable godot linter and fix all its warnings It's important for NeoGo to have clean documentation. No functional changes.
2021-05-12 20:17:03 +00:00
// Types.
vm: implements CONVERT opcode
2020-04-28 08:24:02 +00:00
ISNULL Opcode = 0xD8
ISTYPE Opcode = 0xD9
CONVERT Opcode = 0xDB
vm: move opcodes into their own package This allows easier reuse of opcodes and in some cases allows to eliminate dependencies on the whole vm package, like in compiler that only needs opcodes and doesn't care about VM for any other purpose. And yes, they're opcodes because an instruction is a whole thing with operands, that's what context.Next() returns.
2019-12-03 14:05:06 +00:00
)
vm: add instruction correctness check See neo-project/neo-vm#392.
2021-02-09 14:03:06 +00:00
opcode: optimize IsValid Map access costs much more than array access. name old time/op new time/op delta IsValid-8 17.6ns ± 2% 1.1ns ± 2% -93.68% (p=0.008 n=5+5)
2021-08-02 18:46:19 +00:00
var validCodes [256]bool
func init() {
// We rely on stringer here, it has a map anyway.
for op := range _Opcode_map {
validCodes[int(op)] = true
}
}
vm: add instruction correctness check See neo-project/neo-vm#392.
2021-02-09 14:03:06 +00:00
// IsValid returns true if the opcode passed is valid (defined in the VM).
func IsValid(op Opcode) bool {
opcode: optimize IsValid Map access costs much more than array access. name old time/op new time/op delta IsValid-8 17.6ns ± 2% 1.1ns ± 2% -93.68% (p=0.008 n=5+5)
2021-08-02 18:46:19 +00:00
return validCodes[int(op)]
vm: add instruction correctness check See neo-project/neo-vm#392.
2021-02-09 14:03:06 +00:00
}
Reference in a new issue Copy permalink