status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
nimbus-eth1/nimbus/evm/interpreter/op_handlers/oph_defs.nim

94 lines
2.7 KiB
Nim
Raw Normal View History

experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
# Nimbus
simplify EVM callback (#2282) The EVM callbacks currently don't require closures, so we can use `nimcall` to reduce overhead slightly.
2024-06-02 11:00:27 +00:00
# Copyright (c) 2018-2024 Status Research & Development GmbH
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
# http://www.apache.org/licenses/LICENSE-2.0)
# * MIT license ([LICENSE-MIT](LICENSE-MIT) or
# http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except
# according to those terms.
re-integrated 0x3# op handlers
2021-04-13 17:12:47 +00:00
## EVM Opcodes, Definitions
## ========================
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
##
import
removed circular import dependencies overview: can be verified by running "make check_vm2 X=0" in the nimbus directory (be patient when running it.) the X=0 flag is necessary if there is a native NIM compiler which may bail out at some vendor imports. details: when compiling state_transaction.nim, the nim flag vm2_enabled must be set in order to avoid implicit import of native VM definitions.
2021-04-26 12:03:20 +00:00
../../types,
saner source code grouping
2022-12-02 04:35:41 +00:00
../../../common/evmforks,
Reduce Nim 1.6 compiler warnings & hints * Reduce Nim 1.6 compiler warnings/hints for Fluffy and Nimbus proxy Mostly raises Defect removals, TaintedString removal and some unnecessary imports. Also updating the copyright years alongside. * Further reduce Nim 1.6 compiler warnings/hints for Nimbus
2023-01-31 12:38:08 +00:00
../op_codes
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
type
update handler prototype using call-by-reference argument why: this allows for passing back information which can eventually be used for reducing use of exceptions caveat: call/create currently needs to un-capture the call-by-reference (wrapper) argument using the Computation reference inside
2021-04-20 12:07:01 +00:00
Vm2Ctx* = tuple
cpt: Computation ## computation text
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
Vm2OpFn* = ## general op handler, return codes are passed
## back via argument descriptor ``k``
simplify EVM callback (#2282) The EVM callbacks currently don't require closures, so we can use `nimcall` to reduce overhead slightly.
2024-06-02 11:00:27 +00:00
proc(k: var Vm2Ctx) {.nimcall, gcsafe, raises: [CatchableError].}
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
Vm2OpHanders* = tuple ## three step op code execution, typically
## only the ``run`` entry is activated
prep: Vm2OpFn
run: Vm2OpFn
post: Vm2OpFn
Vm2OpExec* = tuple ## op code handler entry
opCode: Op ## index back-reference
saner source code grouping
2022-12-02 04:35:41 +00:00
forks: set[EVMFork] ## forks applicable for this operation
verifying new op handler tables layout against original tables why: the previous approach was replacing the function-lets in opcode_impl.nim by the particulate table handlers. the test functions will verify the the handler functions are sort of correct but not the assignments in the fork tables. the handler names of old and new for tables are checked here. caveat: verifying tables currently takes a while at compile time.
2021-04-19 09:15:35 +00:00
name: string ## handler name
info: string ## handter info, explainer
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
exec: Vm2OpHanders
# ------------------------------------------------------------------------------
# Public
# ------------------------------------------------------------------------------
const
vm2OpIgnore*: Vm2OpFn = ## No operation, placeholder function
update handler prototype using call-by-reference argument why: this allows for passing back information which can eventually be used for reducing use of exceptions caveat: call/create currently needs to un-capture the call-by-reference (wrapper) argument using the Computation reference inside
2021-04-20 12:07:01 +00:00
proc(k: var Vm2Ctx) = discard
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
# similar to: toSeq(Fork).mapIt({it}).foldl(a+b)
Vm2OpAllForks* =
saner source code grouping
2022-12-02 04:35:41 +00:00
{EVMFork.low .. EVMFork.high}
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
Vm2OpHomesteadAndLater* = ## Set of all fork symbols
Vm2OpAllForks - {FkFrontier}
Vm2OpTangerineAndLater* = ## Set of fork symbols starting from Homestead
Vm2OpHomesteadAndLater - {FkHomestead}
Vm2OpSpuriousAndLater* = ## ditto ...
Vm2OpTangerineAndLater - {FkTangerine}
Vm2OpByzantiumAndLater* =
Vm2OpSpuriousAndLater - {FkSpurious}
Vm2OpConstantinopleAndLater* =
Vm2OpByzantiumAndLater - {FkByzantium}
Vm2OpPetersburgAndLater* =
Vm2OpConstantinopleAndLater - {FkConstantinople}
Vm2OpIstanbulAndLater* =
Vm2OpPetersburgAndLater - {FkPetersburg}
Vm2OpBerlinAndLater* =
Vm2OpIstanbulAndLater - {FkIstanbul}
preparation for London hard fork This preparation is needed for subsequent EIPs included in London. - Add London to Fork enum - Block number to fork - Parsing London fork in chain config - Prepare gas costs table for London - Prepare EVM opcode dispatcher for London - Block rewards for London - Prepare hive script for London
2021-06-28 02:01:18 +00:00
Vm2OpLondonAndLater* =
Vm2OpBerlinAndLater - {FkBerlin}
Some of Shanghai: EIP-3651, EIP-3855, EIP-3860 (#1406) * EIP-3651: Warm COINBASE * EIP-3855: PUSH0 instruction * EIP-3860: Limit and meter initcode
2023-01-04 13:11:33 +00:00
Vm2OpParisAndLater* =
Vm2OpLondonAndLater - {FkLondon}
Vm2OpShanghaiAndLater* =
Vm2OpParisAndLater - {FkParis}
implementation of EIP-4844: Shard Blob Transactions (#1440) * EIP-4844: add pointEvaluation precompiled contract * EIP-4844: validate transaction and block header * EIP-4844: implement DataHash Op Code * EIP-4844: txPool support excessDataGas calculation * EIP-4844: make sure tx produce correct txHash * EIP-4844: node should not automatically broadcast blob tx to it's peers * EIP-4844: add test cases * EIP-4844: add EIP-4844 support to t8n tool * EIP-4844: update nim-eth to branch eip-4844 * fix t8n transaction decoding * add t8n test data * EIP-4844: fix blobHash opcode * disable blobHash test when evmc_enable
2023-06-24 13:56:44 +00:00
Vm2OpCancunAndLater* =
implement EIP-1153: Transient storage new EVM opcodes: - TLOAD 0xb3 - TSTORE 0xb4
2023-03-21 13:27:12 +00:00
Vm2OpShanghaiAndLater - {FkShanghai}
experimental op handlers table (tbc.) details: the op handler table is accessible via op_handlers.nim module op handler function implementations are found in the op_handlers/ sub-directory kludge: for development and pre-testing, any new module can be individually compiled setting the kludge flag using -d:kludge:1. this causes some proc/func replacements in turn allowing for omitting imports that would otherwise cause a circular dependency. otherwise individual compilation would fail. in order to prove the overall correctness of the code, the op_handlers.nim is imported by opcodes_impl.nim when compiling all, nimbus or test.
2021-04-12 17:13:30 +00:00
# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------