ethereum.cancun.vm.instructions

EVM Instruction Encoding (Opcodes) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. contents:: Table of Contents :backlinks: none :local:

Introduction

Machine readable representations of EVM instructions, and a mapping to their implementations.

Ops

Enum for EVM Opcodes

class Ops:

ADD

39
    ADD = 0x01

MUL

40
    MUL = 0x02

SUB

41
    SUB = 0x03

DIV

42
    DIV = 0x04

SDIV

43
    SDIV = 0x05

MOD

44
    MOD = 0x06

SMOD

45
    SMOD = 0x07

ADDMOD

46
    ADDMOD = 0x08

MULMOD

47
    MULMOD = 0x09

EXP

48
    EXP = 0x0A

SIGNEXTEND

49
    SIGNEXTEND = 0x0B

LT

52
    LT = 0x10

GT

53
    GT = 0x11

SLT

54
    SLT = 0x12

SGT

55
    SGT = 0x13

EQ

56
    EQ = 0x14

ISZERO

57
    ISZERO = 0x15

AND

60
    AND = 0x16

OR

61
    OR = 0x17

XOR

62
    XOR = 0x18

NOT

63
    NOT = 0x19

BYTE

64
    BYTE = 0x1A

SHL

65
    SHL = 0x1B

SHR

66
    SHR = 0x1C

SAR

67
    SAR = 0x1D

KECCAK

70
    KECCAK = 0x20

ADDRESS

73
    ADDRESS = 0x30

BALANCE

74
    BALANCE = 0x31

ORIGIN

75
    ORIGIN = 0x32

CALLER

76
    CALLER = 0x33

CALLVALUE

77
    CALLVALUE = 0x34

CALLDATALOAD

78
    CALLDATALOAD = 0x35

CALLDATASIZE

79
    CALLDATASIZE = 0x36

CALLDATACOPY

80
    CALLDATACOPY = 0x37

CODESIZE

81
    CODESIZE = 0x38

CODECOPY

82
    CODECOPY = 0x39

GASPRICE

83
    GASPRICE = 0x3A

EXTCODESIZE

84
    EXTCODESIZE = 0x3B

EXTCODECOPY

85
    EXTCODECOPY = 0x3C

RETURNDATASIZE

86
    RETURNDATASIZE = 0x3D

RETURNDATACOPY

87
    RETURNDATACOPY = 0x3E

EXTCODEHASH

88
    EXTCODEHASH = 0x3F

BLOCKHASH

91
    BLOCKHASH = 0x40

COINBASE

92
    COINBASE = 0x41

TIMESTAMP

93
    TIMESTAMP = 0x42

NUMBER

94
    NUMBER = 0x43

PREVRANDAO

95
    PREVRANDAO = 0x44

GASLIMIT

96
    GASLIMIT = 0x45

CHAINID

97
    CHAINID = 0x46

SELFBALANCE

98
    SELFBALANCE = 0x47

BASEFEE

99
    BASEFEE = 0x48

BLOBHASH

100
    BLOBHASH = 0x49

BLOBBASEFEE

101
    BLOBBASEFEE = 0x4A

STOP

104
    STOP = 0x00

JUMP

105
    JUMP = 0x56

JUMPI

106
    JUMPI = 0x57

PC

107
    PC = 0x58

GAS

108
    GAS = 0x5A

JUMPDEST

109
    JUMPDEST = 0x5B

SLOAD

112
    SLOAD = 0x54

SSTORE

113
    SSTORE = 0x55

TLOAD

114
    TLOAD = 0x5C

TSTORE

115
    TSTORE = 0x5D

POP

118
    POP = 0x50

PUSH0

121
    PUSH0 = 0x5F

PUSH1

122
    PUSH1 = 0x60

PUSH2

123
    PUSH2 = 0x61

PUSH3

124
    PUSH3 = 0x62

PUSH4

125
    PUSH4 = 0x63

PUSH5

126
    PUSH5 = 0x64

PUSH6

127
    PUSH6 = 0x65

PUSH7

128
    PUSH7 = 0x66

PUSH8

129
    PUSH8 = 0x67

PUSH9

130
    PUSH9 = 0x68

PUSH10

131
    PUSH10 = 0x69

PUSH11

132
    PUSH11 = 0x6A

PUSH12

133
    PUSH12 = 0x6B

PUSH13

134
    PUSH13 = 0x6C

PUSH14

135
    PUSH14 = 0x6D

PUSH15

136
    PUSH15 = 0x6E

PUSH16

137
    PUSH16 = 0x6F

PUSH17

138
    PUSH17 = 0x70

PUSH18

139
    PUSH18 = 0x71

PUSH19

140
    PUSH19 = 0x72

PUSH20

141
    PUSH20 = 0x73

PUSH21

142
    PUSH21 = 0x74

PUSH22

143
    PUSH22 = 0x75

PUSH23

144
    PUSH23 = 0x76

PUSH24

145
    PUSH24 = 0x77

PUSH25

146
    PUSH25 = 0x78

PUSH26

147
    PUSH26 = 0x79

PUSH27

148
    PUSH27 = 0x7A

PUSH28

149
    PUSH28 = 0x7B

PUSH29

150
    PUSH29 = 0x7C

PUSH30

151
    PUSH30 = 0x7D

PUSH31

152
    PUSH31 = 0x7E

PUSH32

153
    PUSH32 = 0x7F

DUP1

156
    DUP1 = 0x80

DUP2

157
    DUP2 = 0x81

DUP3

158
    DUP3 = 0x82

DUP4

159
    DUP4 = 0x83

DUP5

160
    DUP5 = 0x84

DUP6

161
    DUP6 = 0x85

DUP7

162
    DUP7 = 0x86

DUP8

163
    DUP8 = 0x87

DUP9

164
    DUP9 = 0x88

DUP10

165
    DUP10 = 0x89

DUP11

166
    DUP11 = 0x8A

DUP12

167
    DUP12 = 0x8B

DUP13

168
    DUP13 = 0x8C

DUP14

169
    DUP14 = 0x8D

DUP15

170
    DUP15 = 0x8E

DUP16

171
    DUP16 = 0x8F

SWAP1

174
    SWAP1 = 0x90

SWAP2

175
    SWAP2 = 0x91

SWAP3

176
    SWAP3 = 0x92

SWAP4

177
    SWAP4 = 0x93

SWAP5

178
    SWAP5 = 0x94

SWAP6

179
    SWAP6 = 0x95

SWAP7

180
    SWAP7 = 0x96

SWAP8

181
    SWAP8 = 0x97

SWAP9

182
    SWAP9 = 0x98

SWAP10

183
    SWAP10 = 0x99

SWAP11

184
    SWAP11 = 0x9A

SWAP12

185
    SWAP12 = 0x9B

SWAP13

186
    SWAP13 = 0x9C

SWAP14

187
    SWAP14 = 0x9D

SWAP15

188
    SWAP15 = 0x9E

SWAP16

189
    SWAP16 = 0x9F

MLOAD

192
    MLOAD = 0x51

MSTORE

193
    MSTORE = 0x52

MSTORE8

194
    MSTORE8 = 0x53

MSIZE

195
    MSIZE = 0x59

MCOPY

196
    MCOPY = 0x5E

LOG0

199
    LOG0 = 0xA0

LOG1

200
    LOG1 = 0xA1

LOG2

201
    LOG2 = 0xA2

LOG3

202
    LOG3 = 0xA3

LOG4

203
    LOG4 = 0xA4

CREATE

206
    CREATE = 0xF0

CALL

207
    CALL = 0xF1

CALLCODE

208
    CALLCODE = 0xF2

RETURN

209
    RETURN = 0xF3

DELEGATECALL

210
    DELEGATECALL = 0xF4

CREATE2

211
    CREATE2 = 0xF5

STATICCALL

212
    STATICCALL = 0xFA

REVERT

213
    REVERT = 0xFD

SELFDESTRUCT

214
    SELFDESTRUCT = 0xFF

op_implementation

217
op_implementation: Dict[Ops, Callable] = {
218
    Ops.STOP: control_flow_instructions.stop,
219
    Ops.ADD: arithmetic_instructions.add,
220
    Ops.MUL: arithmetic_instructions.mul,
221
    Ops.SUB: arithmetic_instructions.sub,
222
    Ops.DIV: arithmetic_instructions.div,
223
    Ops.SDIV: arithmetic_instructions.sdiv,
224
    Ops.MOD: arithmetic_instructions.mod,
225
    Ops.SMOD: arithmetic_instructions.smod,
226
    Ops.ADDMOD: arithmetic_instructions.addmod,
227
    Ops.MULMOD: arithmetic_instructions.mulmod,
228
    Ops.EXP: arithmetic_instructions.exp,
229
    Ops.SIGNEXTEND: arithmetic_instructions.signextend,
230
    Ops.LT: comparison_instructions.less_than,
231
    Ops.GT: comparison_instructions.greater_than,
232
    Ops.SLT: comparison_instructions.signed_less_than,
233
    Ops.SGT: comparison_instructions.signed_greater_than,
234
    Ops.EQ: comparison_instructions.equal,
235
    Ops.ISZERO: comparison_instructions.is_zero,
236
    Ops.AND: bitwise_instructions.bitwise_and,
237
    Ops.OR: bitwise_instructions.bitwise_or,
238
    Ops.XOR: bitwise_instructions.bitwise_xor,
239
    Ops.NOT: bitwise_instructions.bitwise_not,
240
    Ops.BYTE: bitwise_instructions.get_byte,
241
    Ops.SHL: bitwise_instructions.bitwise_shl,
242
    Ops.SHR: bitwise_instructions.bitwise_shr,
243
    Ops.SAR: bitwise_instructions.bitwise_sar,
244
    Ops.KECCAK: keccak_instructions.keccak,
245
    Ops.SLOAD: storage_instructions.sload,
246
    Ops.BLOCKHASH: block_instructions.block_hash,
247
    Ops.COINBASE: block_instructions.coinbase,
248
    Ops.TIMESTAMP: block_instructions.timestamp,
249
    Ops.NUMBER: block_instructions.number,
250
    Ops.PREVRANDAO: block_instructions.prev_randao,
251
    Ops.GASLIMIT: block_instructions.gas_limit,
252
    Ops.CHAINID: block_instructions.chain_id,
253
    Ops.MLOAD: memory_instructions.mload,
254
    Ops.MSTORE: memory_instructions.mstore,
255
    Ops.MSTORE8: memory_instructions.mstore8,
256
    Ops.MSIZE: memory_instructions.msize,
257
    Ops.MCOPY: memory_instructions.mcopy,
258
    Ops.ADDRESS: environment_instructions.address,
259
    Ops.BALANCE: environment_instructions.balance,
260
    Ops.ORIGIN: environment_instructions.origin,
261
    Ops.CALLER: environment_instructions.caller,
262
    Ops.CALLVALUE: environment_instructions.callvalue,
263
    Ops.CALLDATALOAD: environment_instructions.calldataload,
264
    Ops.CALLDATASIZE: environment_instructions.calldatasize,
265
    Ops.CALLDATACOPY: environment_instructions.calldatacopy,
266
    Ops.CODESIZE: environment_instructions.codesize,
267
    Ops.CODECOPY: environment_instructions.codecopy,
268
    Ops.GASPRICE: environment_instructions.gasprice,
269
    Ops.EXTCODESIZE: environment_instructions.extcodesize,
270
    Ops.EXTCODECOPY: environment_instructions.extcodecopy,
271
    Ops.RETURNDATASIZE: environment_instructions.returndatasize,
272
    Ops.RETURNDATACOPY: environment_instructions.returndatacopy,
273
    Ops.EXTCODEHASH: environment_instructions.extcodehash,
274
    Ops.SELFBALANCE: environment_instructions.self_balance,
275
    Ops.BASEFEE: environment_instructions.base_fee,
276
    Ops.BLOBHASH: environment_instructions.blob_hash,
277
    Ops.BLOBBASEFEE: environment_instructions.blob_base_fee,
278
    Ops.SSTORE: storage_instructions.sstore,
279
    Ops.TLOAD: storage_instructions.tload,
280
    Ops.TSTORE: storage_instructions.tstore,
281
    Ops.JUMP: control_flow_instructions.jump,
282
    Ops.JUMPI: control_flow_instructions.jumpi,
283
    Ops.PC: control_flow_instructions.pc,
284
    Ops.GAS: control_flow_instructions.gas_left,
285
    Ops.JUMPDEST: control_flow_instructions.jumpdest,
286
    Ops.POP: stack_instructions.pop,
287
    Ops.PUSH0: stack_instructions.push0,
288
    Ops.PUSH1: stack_instructions.push1,
289
    Ops.PUSH2: stack_instructions.push2,
290
    Ops.PUSH3: stack_instructions.push3,
291
    Ops.PUSH4: stack_instructions.push4,
292
    Ops.PUSH5: stack_instructions.push5,
293
    Ops.PUSH6: stack_instructions.push6,
294
    Ops.PUSH7: stack_instructions.push7,
295
    Ops.PUSH8: stack_instructions.push8,
296
    Ops.PUSH9: stack_instructions.push9,
297
    Ops.PUSH10: stack_instructions.push10,
298
    Ops.PUSH11: stack_instructions.push11,
299
    Ops.PUSH12: stack_instructions.push12,
300
    Ops.PUSH13: stack_instructions.push13,
301
    Ops.PUSH14: stack_instructions.push14,
302
    Ops.PUSH15: stack_instructions.push15,
303
    Ops.PUSH16: stack_instructions.push16,
304
    Ops.PUSH17: stack_instructions.push17,
305
    Ops.PUSH18: stack_instructions.push18,
306
    Ops.PUSH19: stack_instructions.push19,
307
    Ops.PUSH20: stack_instructions.push20,
308
    Ops.PUSH21: stack_instructions.push21,
309
    Ops.PUSH22: stack_instructions.push22,
310
    Ops.PUSH23: stack_instructions.push23,
311
    Ops.PUSH24: stack_instructions.push24,
312
    Ops.PUSH25: stack_instructions.push25,
313
    Ops.PUSH26: stack_instructions.push26,
314
    Ops.PUSH27: stack_instructions.push27,
315
    Ops.PUSH28: stack_instructions.push28,
316
    Ops.PUSH29: stack_instructions.push29,
317
    Ops.PUSH30: stack_instructions.push30,
318
    Ops.PUSH31: stack_instructions.push31,
319
    Ops.PUSH32: stack_instructions.push32,
320
    Ops.DUP1: stack_instructions.dup1,
321
    Ops.DUP2: stack_instructions.dup2,
322
    Ops.DUP3: stack_instructions.dup3,
323
    Ops.DUP4: stack_instructions.dup4,
324
    Ops.DUP5: stack_instructions.dup5,
325
    Ops.DUP6: stack_instructions.dup6,
326
    Ops.DUP7: stack_instructions.dup7,
327
    Ops.DUP8: stack_instructions.dup8,
328
    Ops.DUP9: stack_instructions.dup9,
329
    Ops.DUP10: stack_instructions.dup10,
330
    Ops.DUP11: stack_instructions.dup11,
331
    Ops.DUP12: stack_instructions.dup12,
332
    Ops.DUP13: stack_instructions.dup13,
333
    Ops.DUP14: stack_instructions.dup14,
334
    Ops.DUP15: stack_instructions.dup15,
335
    Ops.DUP16: stack_instructions.dup16,
336
    Ops.SWAP1: stack_instructions.swap1,
337
    Ops.SWAP2: stack_instructions.swap2,
338
    Ops.SWAP3: stack_instructions.swap3,
339
    Ops.SWAP4: stack_instructions.swap4,
340
    Ops.SWAP5: stack_instructions.swap5,
341
    Ops.SWAP6: stack_instructions.swap6,
342
    Ops.SWAP7: stack_instructions.swap7,
343
    Ops.SWAP8: stack_instructions.swap8,
344
    Ops.SWAP9: stack_instructions.swap9,
345
    Ops.SWAP10: stack_instructions.swap10,
346
    Ops.SWAP11: stack_instructions.swap11,
347
    Ops.SWAP12: stack_instructions.swap12,
348
    Ops.SWAP13: stack_instructions.swap13,
349
    Ops.SWAP14: stack_instructions.swap14,
350
    Ops.SWAP15: stack_instructions.swap15,
351
    Ops.SWAP16: stack_instructions.swap16,
352
    Ops.LOG0: log_instructions.log0,
353
    Ops.LOG1: log_instructions.log1,
354
    Ops.LOG2: log_instructions.log2,
355
    Ops.LOG3: log_instructions.log3,
356
    Ops.LOG4: log_instructions.log4,
357
    Ops.CREATE: system_instructions.create,
358
    Ops.RETURN: system_instructions.return_,
359
    Ops.CALL: system_instructions.call,
360
    Ops.CALLCODE: system_instructions.callcode,
361
    Ops.DELEGATECALL: system_instructions.delegatecall,
362
    Ops.SELFDESTRUCT: system_instructions.selfdestruct,
363
    Ops.STATICCALL: system_instructions.staticcall,
364
    Ops.REVERT: system_instructions.revert,
365
    Ops.CREATE2: system_instructions.create2,
366
}