aboutsummaryrefslogtreecommitdiffstats
path: root/core/vm/evm/jump_table.go
diff options
context:
space:
mode:
Diffstat (limited to 'core/vm/evm/jump_table.go')
-rw-r--r--core/vm/evm/jump_table.go972
1 files changed, 972 insertions, 0 deletions
diff --git a/core/vm/evm/jump_table.go b/core/vm/evm/jump_table.go
new file mode 100644
index 000000000..da2f50c5a
--- /dev/null
+++ b/core/vm/evm/jump_table.go
@@ -0,0 +1,972 @@
+// Copyright 2015 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package evm
+
+import (
+ "errors"
+ "math/big"
+
+ "github.com/dexon-foundation/dexon/core/vm"
+ "github.com/dexon-foundation/dexon/params"
+)
+
+type (
+ executionFunc func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *vm.Memory, stack *vm.Stack) ([]byte, error)
+ gasFunc func(params.GasTable, *EVM, *Contract, *vm.Stack, *vm.Memory, uint64) (uint64, error) // last parameter is the requested memory size as a uint64
+ memorySizeFunc func(*vm.Stack) *big.Int
+)
+
+var errGasUintOverflow = errors.New("gas uint64 overflow")
+
+type operation struct {
+ // execute is the operation function
+ execute executionFunc
+ // gasCost is the gas function and returns the gas required for execution
+ gasCost gasFunc
+ // validateStack validates the stack (size) for the operation
+ validateStack vm.StackValidationFunc
+ // memorySize returns the memory size required for the operation
+ memorySize memorySizeFunc
+
+ halts bool // indicates whether the operation should halt further execution
+ jumps bool // indicates whether the program counter should not increment
+ writes bool // determines whether this a state modifying operation
+ valid bool // indication whether the retrieved operation is valid and known
+ reverts bool // determines whether the operation reverts state (implicitly halts)
+ returns bool // determines whether the operations sets the return data content
+}
+
+var (
+ frontierInstructionSet = newFrontierInstructionSet()
+ homesteadInstructionSet = newHomesteadInstructionSet()
+ byzantiumInstructionSet = newByzantiumInstructionSet()
+ constantinopleInstructionSet = newConstantinopleInstructionSet()
+)
+
+// NewConstantinopleInstructionSet returns the frontier, homestead
+// byzantium and contantinople instructions.
+func newConstantinopleInstructionSet() [256]operation {
+ // instructions that can be executed during the byzantium phase.
+ instructionSet := newByzantiumInstructionSet()
+ instructionSet[SHL] = operation{
+ execute: opSHL,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ }
+ instructionSet[SHR] = operation{
+ execute: opSHR,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ }
+ instructionSet[SAR] = operation{
+ execute: opSAR,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ }
+ instructionSet[EXTCODEHASH] = operation{
+ execute: opExtCodeHash,
+ gasCost: gasExtCodeHash,
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ }
+ instructionSet[CREATE2] = operation{
+ execute: opCreate2,
+ gasCost: gasCreate2,
+ validateStack: vm.MakeStackFunc(4, 1),
+ memorySize: memoryCreate2,
+ valid: true,
+ writes: true,
+ returns: true,
+ }
+ return instructionSet
+}
+
+// NewByzantiumInstructionSet returns the frontier, homestead and
+// byzantium instructions.
+func newByzantiumInstructionSet() [256]operation {
+ // instructions that can be executed during the homestead phase.
+ instructionSet := newHomesteadInstructionSet()
+ instructionSet[STATICCALL] = operation{
+ execute: opStaticCall,
+ gasCost: gasStaticCall,
+ validateStack: vm.MakeStackFunc(6, 1),
+ memorySize: memoryStaticCall,
+ valid: true,
+ returns: true,
+ }
+ instructionSet[RETURNDATASIZE] = operation{
+ execute: opReturnDataSize,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ }
+ instructionSet[RETURNDATACOPY] = operation{
+ execute: opReturnDataCopy,
+ gasCost: gasReturnDataCopy,
+ validateStack: vm.MakeStackFunc(3, 0),
+ memorySize: memoryReturnDataCopy,
+ valid: true,
+ }
+ instructionSet[REVERT] = operation{
+ execute: opRevert,
+ gasCost: gasRevert,
+ validateStack: vm.MakeStackFunc(2, 0),
+ memorySize: memoryRevert,
+ valid: true,
+ reverts: true,
+ returns: true,
+ }
+ return instructionSet
+}
+
+// NewHomesteadInstructionSet returns the frontier and homestead
+// instructions that can be executed during the homestead phase.
+func newHomesteadInstructionSet() [256]operation {
+ instructionSet := newFrontierInstructionSet()
+ instructionSet[DELEGATECALL] = operation{
+ execute: opDelegateCall,
+ gasCost: gasDelegateCall,
+ validateStack: vm.MakeStackFunc(6, 1),
+ memorySize: memoryDelegateCall,
+ valid: true,
+ returns: true,
+ }
+ return instructionSet
+}
+
+// NewFrontierInstructionSet returns the frontier instructions
+// that can be executed during the frontier phase.
+func newFrontierInstructionSet() [256]operation {
+ return [256]operation{
+ STOP: {
+ execute: opStop,
+ gasCost: constGasFunc(0),
+ validateStack: vm.MakeStackFunc(0, 0),
+ halts: true,
+ valid: true,
+ },
+ ADD: {
+ execute: opAdd,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ MUL: {
+ execute: opMul,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SUB: {
+ execute: opSub,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ DIV: {
+ execute: opDiv,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SDIV: {
+ execute: opSdiv,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ MOD: {
+ execute: opMod,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SMOD: {
+ execute: opSmod,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ ADDMOD: {
+ execute: opAddmod,
+ gasCost: constGasFunc(GasMidStep),
+ validateStack: vm.MakeStackFunc(3, 1),
+ valid: true,
+ },
+ MULMOD: {
+ execute: opMulmod,
+ gasCost: constGasFunc(GasMidStep),
+ validateStack: vm.MakeStackFunc(3, 1),
+ valid: true,
+ },
+ EXP: {
+ execute: opExp,
+ gasCost: gasExp,
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SIGNEXTEND: {
+ execute: opSignExtend,
+ gasCost: constGasFunc(GasFastStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ LT: {
+ execute: opLt,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ GT: {
+ execute: opGt,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SLT: {
+ execute: opSlt,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SGT: {
+ execute: opSgt,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ EQ: {
+ execute: opEq,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ ISZERO: {
+ execute: opIszero,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ AND: {
+ execute: opAnd,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ XOR: {
+ execute: opXor,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ OR: {
+ execute: opOr,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ NOT: {
+ execute: opNot,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ BYTE: {
+ execute: opByte,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(2, 1),
+ valid: true,
+ },
+ SHA3: {
+ execute: opSha3,
+ gasCost: gasSha3,
+ validateStack: vm.MakeStackFunc(2, 1),
+ memorySize: memorySha3,
+ valid: true,
+ },
+ RAND: {
+ execute: opRand,
+ gasCost: constGasFunc(params.RandGas),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ ADDRESS: {
+ execute: opAddress,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ BALANCE: {
+ execute: opBalance,
+ gasCost: gasBalance,
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ ORIGIN: {
+ execute: opOrigin,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ CALLER: {
+ execute: opCaller,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ CALLVALUE: {
+ execute: opCallValue,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ CALLDATALOAD: {
+ execute: opCallDataLoad,
+ gasCost: constGasFunc(GasFastestStep),
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ CALLDATASIZE: {
+ execute: opCallDataSize,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ CALLDATACOPY: {
+ execute: opCallDataCopy,
+ gasCost: gasCallDataCopy,
+ validateStack: vm.MakeStackFunc(3, 0),
+ memorySize: memoryCallDataCopy,
+ valid: true,
+ },
+ CODESIZE: {
+ execute: opCodeSize,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ CODECOPY: {
+ execute: opCodeCopy,
+ gasCost: gasCodeCopy,
+ validateStack: vm.MakeStackFunc(3, 0),
+ memorySize: memoryCodeCopy,
+ valid: true,
+ },
+ GASPRICE: {
+ execute: opGasprice,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ EXTCODESIZE: {
+ execute: opExtCodeSize,
+ gasCost: gasExtCodeSize,
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ EXTCODECOPY: {
+ execute: opExtCodeCopy,
+ gasCost: gasExtCodeCopy,
+ validateStack: vm.MakeStackFunc(4, 0),
+ memorySize: memoryExtCodeCopy,
+ valid: true,
+ },
+ BLOCKHASH: {
+ execute: opBlockhash,
+ gasCost: constGasFunc(GasExtStep),
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ COINBASE: {
+ execute: opCoinbase,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ TIMESTAMP: {
+ execute: opTimestamp,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ NUMBER: {
+ execute: opNumber,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ DIFFICULTY: {
+ execute: opDifficulty,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ GASLIMIT: {
+ execute: opGasLimit,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ POP: {
+ execute: opPop,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(1, 0),
+ valid: true,
+ },
+ MLOAD: {
+ execute: opMload,
+ gasCost: gasMLoad,
+ validateStack: vm.MakeStackFunc(1, 1),
+ memorySize: memoryMLoad,
+ valid: true,
+ },
+ MSTORE: {
+ execute: opMstore,
+ gasCost: gasMStore,
+ validateStack: vm.MakeStackFunc(2, 0),
+ memorySize: memoryMStore,
+ valid: true,
+ },
+ MSTORE8: {
+ execute: opMstore8,
+ gasCost: gasMStore8,
+ memorySize: memoryMStore8,
+ validateStack: vm.MakeStackFunc(2, 0),
+
+ valid: true,
+ },
+ SLOAD: {
+ execute: opSload,
+ gasCost: gasSLoad,
+ validateStack: vm.MakeStackFunc(1, 1),
+ valid: true,
+ },
+ SSTORE: {
+ execute: opSstore,
+ gasCost: gasSStore,
+ validateStack: vm.MakeStackFunc(2, 0),
+ valid: true,
+ writes: true,
+ },
+ JUMP: {
+ execute: opJump,
+ gasCost: constGasFunc(GasMidStep),
+ validateStack: vm.MakeStackFunc(1, 0),
+ jumps: true,
+ valid: true,
+ },
+ JUMPI: {
+ execute: opJumpi,
+ gasCost: constGasFunc(GasSlowStep),
+ validateStack: vm.MakeStackFunc(2, 0),
+ jumps: true,
+ valid: true,
+ },
+ PC: {
+ execute: opPc,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ MSIZE: {
+ execute: opMsize,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ GAS: {
+ execute: opGas,
+ gasCost: constGasFunc(GasQuickStep),
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ JUMPDEST: {
+ execute: opJumpdest,
+ gasCost: constGasFunc(params.JumpdestGas),
+ validateStack: vm.MakeStackFunc(0, 0),
+ valid: true,
+ },
+ PUSH1: {
+ execute: makePush(1, 1),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH2: {
+ execute: makePush(2, 2),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH3: {
+ execute: makePush(3, 3),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH4: {
+ execute: makePush(4, 4),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH5: {
+ execute: makePush(5, 5),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH6: {
+ execute: makePush(6, 6),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH7: {
+ execute: makePush(7, 7),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH8: {
+ execute: makePush(8, 8),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH9: {
+ execute: makePush(9, 9),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH10: {
+ execute: makePush(10, 10),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH11: {
+ execute: makePush(11, 11),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH12: {
+ execute: makePush(12, 12),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH13: {
+ execute: makePush(13, 13),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH14: {
+ execute: makePush(14, 14),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH15: {
+ execute: makePush(15, 15),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH16: {
+ execute: makePush(16, 16),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH17: {
+ execute: makePush(17, 17),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH18: {
+ execute: makePush(18, 18),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH19: {
+ execute: makePush(19, 19),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH20: {
+ execute: makePush(20, 20),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH21: {
+ execute: makePush(21, 21),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH22: {
+ execute: makePush(22, 22),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH23: {
+ execute: makePush(23, 23),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH24: {
+ execute: makePush(24, 24),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH25: {
+ execute: makePush(25, 25),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH26: {
+ execute: makePush(26, 26),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH27: {
+ execute: makePush(27, 27),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH28: {
+ execute: makePush(28, 28),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH29: {
+ execute: makePush(29, 29),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH30: {
+ execute: makePush(30, 30),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH31: {
+ execute: makePush(31, 31),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ PUSH32: {
+ execute: makePush(32, 32),
+ gasCost: gasPush,
+ validateStack: vm.MakeStackFunc(0, 1),
+ valid: true,
+ },
+ DUP1: {
+ execute: makeDup(1),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(1),
+ valid: true,
+ },
+ DUP2: {
+ execute: makeDup(2),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(2),
+ valid: true,
+ },
+ DUP3: {
+ execute: makeDup(3),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(3),
+ valid: true,
+ },
+ DUP4: {
+ execute: makeDup(4),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(4),
+ valid: true,
+ },
+ DUP5: {
+ execute: makeDup(5),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(5),
+ valid: true,
+ },
+ DUP6: {
+ execute: makeDup(6),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(6),
+ valid: true,
+ },
+ DUP7: {
+ execute: makeDup(7),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(7),
+ valid: true,
+ },
+ DUP8: {
+ execute: makeDup(8),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(8),
+ valid: true,
+ },
+ DUP9: {
+ execute: makeDup(9),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(9),
+ valid: true,
+ },
+ DUP10: {
+ execute: makeDup(10),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(10),
+ valid: true,
+ },
+ DUP11: {
+ execute: makeDup(11),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(11),
+ valid: true,
+ },
+ DUP12: {
+ execute: makeDup(12),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(12),
+ valid: true,
+ },
+ DUP13: {
+ execute: makeDup(13),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(13),
+ valid: true,
+ },
+ DUP14: {
+ execute: makeDup(14),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(14),
+ valid: true,
+ },
+ DUP15: {
+ execute: makeDup(15),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(15),
+ valid: true,
+ },
+ DUP16: {
+ execute: makeDup(16),
+ gasCost: gasDup,
+ validateStack: vm.MakeDupStackFunc(16),
+ valid: true,
+ },
+ SWAP1: {
+ execute: makeSwap(1),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(2),
+ valid: true,
+ },
+ SWAP2: {
+ execute: makeSwap(2),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(3),
+ valid: true,
+ },
+ SWAP3: {
+ execute: makeSwap(3),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(4),
+ valid: true,
+ },
+ SWAP4: {
+ execute: makeSwap(4),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(5),
+ valid: true,
+ },
+ SWAP5: {
+ execute: makeSwap(5),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(6),
+ valid: true,
+ },
+ SWAP6: {
+ execute: makeSwap(6),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(7),
+ valid: true,
+ },
+ SWAP7: {
+ execute: makeSwap(7),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(8),
+ valid: true,
+ },
+ SWAP8: {
+ execute: makeSwap(8),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(9),
+ valid: true,
+ },
+ SWAP9: {
+ execute: makeSwap(9),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(10),
+ valid: true,
+ },
+ SWAP10: {
+ execute: makeSwap(10),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(11),
+ valid: true,
+ },
+ SWAP11: {
+ execute: makeSwap(11),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(12),
+ valid: true,
+ },
+ SWAP12: {
+ execute: makeSwap(12),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(13),
+ valid: true,
+ },
+ SWAP13: {
+ execute: makeSwap(13),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(14),
+ valid: true,
+ },
+ SWAP14: {
+ execute: makeSwap(14),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(15),
+ valid: true,
+ },
+ SWAP15: {
+ execute: makeSwap(15),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(16),
+ valid: true,
+ },
+ SWAP16: {
+ execute: makeSwap(16),
+ gasCost: gasSwap,
+ validateStack: vm.MakeSwapStackFunc(17),
+ valid: true,
+ },
+ LOG0: {
+ execute: makeLog(0),
+ gasCost: makeGasLog(0),
+ validateStack: vm.MakeStackFunc(2, 0),
+ memorySize: memoryLog,
+ valid: true,
+ writes: true,
+ },
+ LOG1: {
+ execute: makeLog(1),
+ gasCost: makeGasLog(1),
+ validateStack: vm.MakeStackFunc(3, 0),
+ memorySize: memoryLog,
+ valid: true,
+ writes: true,
+ },
+ LOG2: {
+ execute: makeLog(2),
+ gasCost: makeGasLog(2),
+ validateStack: vm.MakeStackFunc(4, 0),
+ memorySize: memoryLog,
+ valid: true,
+ writes: true,
+ },
+ LOG3: {
+ execute: makeLog(3),
+ gasCost: makeGasLog(3),
+ validateStack: vm.MakeStackFunc(5, 0),
+ memorySize: memoryLog,
+ valid: true,
+ writes: true,
+ },
+ LOG4: {
+ execute: makeLog(4),
+ gasCost: makeGasLog(4),
+ validateStack: vm.MakeStackFunc(6, 0),
+ memorySize: memoryLog,
+ valid: true,
+ writes: true,
+ },
+ CREATE: {
+ execute: opCreate,
+ gasCost: gasCreate,
+ validateStack: vm.MakeStackFunc(3, 1),
+ memorySize: memoryCreate,
+ valid: true,
+ writes: true,
+ returns: true,
+ },
+ CALL: {
+ execute: opCall,
+ gasCost: gasCall,
+ validateStack: vm.MakeStackFunc(7, 1),
+ memorySize: memoryCall,
+ valid: true,
+ returns: true,
+ },
+ CALLCODE: {
+ execute: opCallCode,
+ gasCost: gasCallCode,
+ validateStack: vm.MakeStackFunc(7, 1),
+ memorySize: memoryCall,
+ valid: true,
+ returns: true,
+ },
+ RETURN: {
+ execute: opReturn,
+ gasCost: gasReturn,
+ validateStack: vm.MakeStackFunc(2, 0),
+ memorySize: memoryReturn,
+ halts: true,
+ valid: true,
+ },
+ SELFDESTRUCT: {
+ execute: opSuicide,
+ gasCost: gasSuicide,
+ validateStack: vm.MakeStackFunc(1, 0),
+ halts: true,
+ valid: true,
+ writes: true,
+ },
+ }
+}
generated by cgit (git 2.34.1) at 2024-11-12 14:09:59 +0800