EVM cosmetic changes, one less indirect access of VmCpt (#2503)
This commit is contained in:
andri lim
GitHub
parent
5ac362fe6f
commit
fb196849ee
|
|
@ -36,42 +36,42 @@ export
|
|||
# Helpers
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
template handleStopDirective(k: var VmCtx) =
|
||||
template handleStopDirective(cpt: VmCpt) =
|
||||
#trace "op: Stop"
|
||||
if not k.cpt.code.atEnd() and k.cpt.tracingEnabled:
|
||||
if not cpt.code.atEnd() and cpt.tracingEnabled:
|
||||
# we only trace `REAL STOP` and ignore `FAKE STOP`
|
||||
k.cpt.opIndex = k.cpt.traceOpCodeStarted(Stop)
|
||||
k.cpt.traceOpCodeEnded(Stop, k.cpt.opIndex)
|
||||
cpt.opIndex = cpt.traceOpCodeStarted(Stop)
|
||||
cpt.traceOpCodeEnded(Stop, cpt.opIndex)
|
||||
|
||||
|
||||
template handleFixedGasCostsDirective(fork: EVMFork; op: Op; k: var VmCtx) =
|
||||
if k.cpt.tracingEnabled:
|
||||
k.cpt.opIndex = k.cpt.traceOpCodeStarted(op)
|
||||
template handleFixedGasCostsDirective(fork: EVMFork; op: Op; cpt: VmCpt) =
|
||||
if cpt.tracingEnabled:
|
||||
cpt.opIndex = cpt.traceOpCodeStarted(op)
|
||||
|
||||
? k.cpt.opcodeGasCost(op, k.cpt.gasCosts[op].cost, reason = $op)
|
||||
? vmOpHandlers[fork][op].run(k)
|
||||
? cpt.opcodeGasCost(op, cpt.gasCosts[op].cost, reason = $op)
|
||||
? vmOpHandlers[fork][op].run(cpt)
|
||||
|
||||
# If continuation is not nil, traceOpCodeEnded will be called in executeOpcodes.
|
||||
if k.cpt.tracingEnabled and k.cpt.continuation.isNil:
|
||||
k.cpt.traceOpCodeEnded(op, k.cpt.opIndex)
|
||||
if cpt.tracingEnabled and cpt.continuation.isNil:
|
||||
cpt.traceOpCodeEnded(op, cpt.opIndex)
|
||||
|
||||
|
||||
template handleOtherDirective(fork: EVMFork; op: Op; k: var VmCtx) =
|
||||
if k.cpt.tracingEnabled:
|
||||
k.cpt.opIndex = k.cpt.traceOpCodeStarted(op)
|
||||
template handleOtherDirective(fork: EVMFork; op: Op; cpt: VmCpt) =
|
||||
if cpt.tracingEnabled:
|
||||
cpt.opIndex = cpt.traceOpCodeStarted(op)
|
||||
|
||||
? vmOpHandlers[fork][op].run(k)
|
||||
? vmOpHandlers[fork][op].run(cpt)
|
||||
|
||||
# If continuation is not nil, traceOpCodeEnded will be called in executeOpcodes.
|
||||
if k.cpt.tracingEnabled and k.cpt.continuation.isNil:
|
||||
k.cpt.traceOpCodeEnded(op, k.cpt.opIndex)
|
||||
if cpt.tracingEnabled and cpt.continuation.isNil:
|
||||
cpt.traceOpCodeEnded(op, cpt.opIndex)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Private, big nasty doubly nested case matrix generator
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
# reminiscent of Mamy's opTableToCaseStmt() from original VM
|
||||
proc toCaseStmt(forkArg, opArg, k: NimNode): NimNode =
|
||||
proc toCaseStmt(forkArg, opArg, cpt: NimNode): NimNode =
|
||||
|
||||
# Outer case/switch => Op
|
||||
let branchOnOp = quote do: `opArg`
|
||||
|
|
@ -89,13 +89,13 @@ proc toCaseStmt(forkArg, opArg, k: NimNode): NimNode =
|
|||
let branchStmt = block:
|
||||
if op == Stop:
|
||||
quote do:
|
||||
handleStopDirective(`k`)
|
||||
handleStopDirective(`cpt`)
|
||||
elif gcTable[op] == GckFixed:
|
||||
quote do:
|
||||
handleFixedGasCostsDirective(`asFork`,`asOp`,`k`)
|
||||
handleFixedGasCostsDirective(`asFork`,`asOp`,`cpt`)
|
||||
else:
|
||||
quote do:
|
||||
handleOtherDirective(`asFork`,`asOp`,`k`)
|
||||
handleOtherDirective(`asFork`,`asOp`,`cpt`)
|
||||
|
||||
forkCaseSubExpr.add nnkOfBranch.newTree(asFork, branchStmt)
|
||||
|
||||
|
|
@ -112,7 +112,7 @@ proc toCaseStmt(forkArg, opArg, k: NimNode): NimNode =
|
|||
# break no matter what).
|
||||
quote do:
|
||||
`forkCaseSubExpr`
|
||||
if not `k`.cpt.continuation.isNil:
|
||||
if not `cpt`.continuation.isNil:
|
||||
break
|
||||
|
||||
result.add nnkOfBranch.newTree(asOp, branchStmt)
|
||||
|
|
@ -124,26 +124,26 @@ proc toCaseStmt(forkArg, opArg, k: NimNode): NimNode =
|
|||
# Public macros/functions
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
macro genOptimisedDispatcher*(fork: EVMFork; op: Op; k: VmCtx): untyped =
|
||||
result = fork.toCaseStmt(op, k)
|
||||
macro genOptimisedDispatcher*(fork: EVMFork; op: Op; cpt: VmCpt): untyped =
|
||||
result = fork.toCaseStmt(op, cpt)
|
||||
|
||||
|
||||
template genLowMemDispatcher*(fork: EVMFork; op: Op; k: VmCtx) =
|
||||
template genLowMemDispatcher*(fork: EVMFork; op: Op; cpt: VmCpt) =
|
||||
if op == Stop:
|
||||
handleStopDirective(k)
|
||||
handleStopDirective(cpt)
|
||||
break
|
||||
|
||||
if BaseGasCosts[op].kind == GckFixed:
|
||||
handleFixedGasCostsDirective(fork, op, k)
|
||||
handleFixedGasCostsDirective(fork, op, cpt)
|
||||
else:
|
||||
handleOtherDirective(fork, op, k)
|
||||
handleOtherDirective(fork, op, cpt)
|
||||
|
||||
case c.instr
|
||||
case cpt.instr
|
||||
of Return, Revert, SelfDestruct:
|
||||
break
|
||||
else:
|
||||
# FIXME-manyOpcodesNowRequireContinuations
|
||||
if not k.cpt.continuation.isNil:
|
||||
if not cpt.continuation.isNil:
|
||||
break
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
@ -154,10 +154,9 @@ when isMainModule and isChatty:
|
|||
|
||||
import ../types
|
||||
|
||||
proc optimised(c: Computation, fork: EVMFork): EvmResultVoid {.compileTime.} =
|
||||
var desc: VmCtx
|
||||
proc optimised(cpt: VmCpt, fork: EVMFork): EvmResultVoid {.compileTime.} =
|
||||
while true:
|
||||
genOptimisedDispatcher(fork, desc.cpt.instr, desc)
|
||||
genOptimisedDispatcher(fork, cpt.instr, desc)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
|
|
|
|||
|
|
@ -122,9 +122,9 @@ const
|
|||
|
||||
when isMainModule and isChatty:
|
||||
|
||||
proc opHandlersRun(fork: EVMFork; op: Op; d: var VmCtx) {.used.} =
|
||||
proc opHandlersRun(fork: EVMFork; op: Op; cpt: VmCpt) {.used.} =
|
||||
## Given a particular `fork` and an `op`-code, run the associated handler
|
||||
vmOpHandlers[fork][op].run(d)
|
||||
vmOpHandlers[fork][op].run(cpt)
|
||||
|
||||
proc opHandlersName(fork: EVMFork; op: Op): string {.used.} =
|
||||
## Get name (or ID) of op handler
|
||||
|
|
|
|||
|
|
@ -37,19 +37,19 @@ func slt(x, y: UInt256): bool =
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc addOp (k: var VmCtx): EvmResultVoid =
|
||||
proc addOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x01, Addition
|
||||
k.cpt.stack.binaryOp(`+`)
|
||||
cpt.stack.binaryOp(`+`)
|
||||
|
||||
proc mulOp(k: var VmCtx): EvmResultVoid =
|
||||
proc mulOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x02, Multiplication
|
||||
k.cpt.stack.binaryOp(`*`)
|
||||
cpt.stack.binaryOp(`*`)
|
||||
|
||||
proc subOp(k: var VmCtx): EvmResultVoid =
|
||||
proc subOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x03, Substraction
|
||||
k.cpt.stack.binaryOp(`-`)
|
||||
cpt.stack.binaryOp(`-`)
|
||||
|
||||
proc divideOp(k: var VmCtx): EvmResultVoid =
|
||||
proc divideOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x04, Division
|
||||
template div256(top, lhs, rhs) =
|
||||
if rhs.isZero:
|
||||
|
|
@ -58,9 +58,9 @@ proc divideOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = lhs div rhs
|
||||
|
||||
k.cpt.stack.binaryWithTop(div256)
|
||||
cpt.stack.binaryWithTop(div256)
|
||||
|
||||
proc sdivOp(k: var VmCtx): EvmResultVoid =
|
||||
proc sdivOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x05, Signed division
|
||||
template sdiv256(top, lhs, rhs) =
|
||||
if rhs.isZero.not:
|
||||
|
|
@ -70,9 +70,9 @@ proc sdivOp(k: var VmCtx): EvmResultVoid =
|
|||
top = lhs div rhs
|
||||
setSign(top, signA xor signB)
|
||||
|
||||
k.cpt.stack.binaryWithTop(sdiv256)
|
||||
cpt.stack.binaryWithTop(sdiv256)
|
||||
|
||||
proc moduloOp(k: var VmCtx): EvmResultVoid =
|
||||
proc moduloOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x06, Modulo
|
||||
template mod256(top, lhs, rhs) =
|
||||
if rhs.isZero:
|
||||
|
|
@ -80,9 +80,9 @@ proc moduloOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = lhs mod rhs
|
||||
|
||||
k.cpt.stack.binaryWithTop(mod256)
|
||||
cpt.stack.binaryWithTop(mod256)
|
||||
|
||||
proc smodOp(k: var VmCtx): EvmResultVoid =
|
||||
proc smodOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x07, Signed modulo
|
||||
template smod256(top, lhs, rhs) =
|
||||
if rhs.isZero.not:
|
||||
|
|
@ -92,47 +92,47 @@ proc smodOp(k: var VmCtx): EvmResultVoid =
|
|||
top = lhs mod rhs
|
||||
setSign(top, sign)
|
||||
|
||||
k.cpt.stack.binaryWithTop(smod256)
|
||||
cpt.stack.binaryWithTop(smod256)
|
||||
|
||||
proc addmodOp(k: var VmCtx): EvmResultVoid =
|
||||
proc addmodOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x08, Modulo addition
|
||||
## Intermediate computations do not roll over at 2^256
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
lhs = k.cpt.stack.lsPeekInt(^1)
|
||||
rhs = k.cpt.stack.lsPeekInt(^2)
|
||||
modulus = k.cpt.stack.lsPeekInt(^3)
|
||||
lhs = cpt.stack.lsPeekInt(^1)
|
||||
rhs = cpt.stack.lsPeekInt(^2)
|
||||
modulus = cpt.stack.lsPeekInt(^3)
|
||||
value = if modulus.isZero:
|
||||
zero(UInt256)
|
||||
else:
|
||||
addmod(lhs, rhs, modulus)
|
||||
|
||||
k.cpt.stack.lsShrink(2)
|
||||
k.cpt.stack.lsTop value
|
||||
cpt.stack.lsShrink(2)
|
||||
cpt.stack.lsTop value
|
||||
ok()
|
||||
|
||||
proc mulmodOp(k: var VmCtx): EvmResultVoid =
|
||||
proc mulmodOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x09, Modulo multiplication
|
||||
## Intermediate computations do not roll over at 2^256
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
lhs = k.cpt.stack.lsPeekInt(^1)
|
||||
rhs = k.cpt.stack.lsPeekInt(^2)
|
||||
modulus = k.cpt.stack.lsPeekInt(^3)
|
||||
lhs = cpt.stack.lsPeekInt(^1)
|
||||
rhs = cpt.stack.lsPeekInt(^2)
|
||||
modulus = cpt.stack.lsPeekInt(^3)
|
||||
value = if modulus.isZero:
|
||||
zero(UInt256)
|
||||
else:
|
||||
mulmod(lhs, rhs, modulus)
|
||||
|
||||
k.cpt.stack.lsShrink(2)
|
||||
k.cpt.stack.lsTop value
|
||||
cpt.stack.lsShrink(2)
|
||||
cpt.stack.lsTop value
|
||||
ok()
|
||||
|
||||
proc expOp(k: var VmCtx): EvmResultVoid =
|
||||
proc expOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x0A, Exponentiation
|
||||
template exp256(top, base, exponent) =
|
||||
? k.cpt.opcodeGasCost(Exp,
|
||||
k.cpt.gasCosts[Exp].d_handler(exponent),
|
||||
? cpt.opcodeGasCost(Exp,
|
||||
cpt.gasCosts[Exp].d_handler(exponent),
|
||||
reason = "EXP: exponent bytes")
|
||||
|
||||
if not base.isZero:
|
||||
|
|
@ -145,9 +145,9 @@ proc expOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = zero(UInt256)
|
||||
|
||||
k.cpt.stack.binaryWithTop(exp256)
|
||||
cpt.stack.binaryWithTop(exp256)
|
||||
|
||||
proc signExtendOp(k: var VmCtx): EvmResultVoid =
|
||||
proc signExtendOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x0B, Sign extend
|
||||
## Extend length of two’s complement signed integer.
|
||||
template se256(top, bits, value) =
|
||||
|
|
@ -164,62 +164,62 @@ proc signExtendOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = value
|
||||
|
||||
k.cpt.stack.binaryWithTop(se256)
|
||||
cpt.stack.binaryWithTop(se256)
|
||||
|
||||
proc ltOp(k: var VmCtx): EvmResultVoid =
|
||||
proc ltOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x10, Less-than comparison
|
||||
template lt256(lhs, rhs): auto =
|
||||
(lhs < rhs).uint.u256
|
||||
k.cpt.stack.binaryOp(lt256)
|
||||
cpt.stack.binaryOp(lt256)
|
||||
|
||||
proc gtOp(k: var VmCtx): EvmResultVoid =
|
||||
proc gtOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x11, Greater-than comparison
|
||||
template gt256(lhs, rhs): auto =
|
||||
(lhs > rhs).uint.u256
|
||||
k.cpt.stack.binaryOp(gt256)
|
||||
cpt.stack.binaryOp(gt256)
|
||||
|
||||
proc sltOp(k: var VmCtx): EvmResultVoid =
|
||||
proc sltOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x12, Signed less-than comparison
|
||||
template slt256(lhs, rhs): auto =
|
||||
slt(lhs, rhs).uint.u256
|
||||
k.cpt.stack.binaryOp(slt256)
|
||||
cpt.stack.binaryOp(slt256)
|
||||
|
||||
proc sgtOp(k: var VmCtx): EvmResultVoid =
|
||||
proc sgtOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x13, Signed greater-than comparison
|
||||
# Arguments are swapped and SLT is used.
|
||||
template sgt256(lhs, rhs): auto =
|
||||
slt(rhs, lhs).uint.u256
|
||||
k.cpt.stack.binaryOp(sgt256)
|
||||
cpt.stack.binaryOp(sgt256)
|
||||
|
||||
proc eqOp(k: var VmCtx): EvmResultVoid =
|
||||
proc eqOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x14, Equality comparison
|
||||
template eq256(lhs, rhs): auto =
|
||||
(lhs == rhs).uint.u256
|
||||
k.cpt.stack.binaryOp(eq256)
|
||||
cpt.stack.binaryOp(eq256)
|
||||
|
||||
proc isZeroOp(k: var VmCtx): EvmResultVoid =
|
||||
proc isZeroOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x15, Check if zero
|
||||
template zero256(value): auto =
|
||||
value.isZero.uint.u256
|
||||
k.cpt.stack.unaryOp(zero256)
|
||||
cpt.stack.unaryOp(zero256)
|
||||
|
||||
proc andOp(k: var VmCtx): EvmResultVoid =
|
||||
proc andOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x16, Bitwise AND
|
||||
k.cpt.stack.binaryOp(`and`)
|
||||
cpt.stack.binaryOp(`and`)
|
||||
|
||||
proc orOp(k: var VmCtx): EvmResultVoid =
|
||||
proc orOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x17, Bitwise OR
|
||||
k.cpt.stack.binaryOp(`or`)
|
||||
cpt.stack.binaryOp(`or`)
|
||||
|
||||
proc xorOp(k: var VmCtx): EvmResultVoid =
|
||||
proc xorOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x18, Bitwise XOR
|
||||
k.cpt.stack.binaryOp(`xor`)
|
||||
cpt.stack.binaryOp(`xor`)
|
||||
|
||||
proc notOp(k: var VmCtx): EvmResultVoid =
|
||||
proc notOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x19, Check if zero
|
||||
k.cpt.stack.unaryOp(`not`)
|
||||
cpt.stack.unaryOp(`not`)
|
||||
|
||||
proc byteOp(k: var VmCtx): EvmResultVoid =
|
||||
proc byteOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x20, Retrieve single byte from word.
|
||||
template byte256(top, position, value) =
|
||||
if position >= 32.u256:
|
||||
|
|
@ -231,11 +231,11 @@ proc byteOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = cast[array[32, byte]](value)[31 - pos].u256
|
||||
|
||||
k.cpt.stack.binaryWithTop(byte256)
|
||||
cpt.stack.binaryWithTop(byte256)
|
||||
|
||||
# Constantinople's new opcodes
|
||||
|
||||
proc shlOp(k: var VmCtx): EvmResultVoid =
|
||||
proc shlOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x1b, Shift left
|
||||
template shl256(top, lhs, num) =
|
||||
let shiftLen = lhs.safeInt
|
||||
|
|
@ -244,9 +244,9 @@ proc shlOp(k: var VmCtx): EvmResultVoid =
|
|||
else:
|
||||
top = num shl shiftLen
|
||||
|
||||
k.cpt.stack.binaryWithTop(shl256)
|
||||
cpt.stack.binaryWithTop(shl256)
|
||||
|
||||
proc shrOp(k: var VmCtx): EvmResultVoid =
|
||||
proc shrOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x1c, Shift right logical
|
||||
template shr256(top, lhs, num) =
|
||||
let shiftLen = lhs.safeInt
|
||||
|
|
@ -256,9 +256,9 @@ proc shrOp(k: var VmCtx): EvmResultVoid =
|
|||
# uint version of `shr`
|
||||
top = num shr shiftLen
|
||||
|
||||
k.cpt.stack.binaryWithTop(shr256)
|
||||
cpt.stack.binaryWithTop(shr256)
|
||||
|
||||
proc sarOp(k: var VmCtx): EvmResultVoid =
|
||||
proc sarOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x1d, Shift right arithmetic
|
||||
template sar256(top, lhs, num256) =
|
||||
let
|
||||
|
|
@ -275,7 +275,7 @@ proc sarOp(k: var VmCtx): EvmResultVoid =
|
|||
# into uint256
|
||||
top = cast[UInt256](num shr shiftLen)
|
||||
|
||||
k.cpt.stack.binaryWithTop(sar256)
|
||||
cpt.stack.binaryWithTop(sar256)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public, op exec table entries
|
||||
|
|
|
|||
|
|
@ -30,66 +30,65 @@ when not defined(evmc_enabled):
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc blockhashOp (k: var VmCtx): EvmResultVoid =
|
||||
proc blockhashOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x40, Get the hash of one of the 256 most recent complete blocks.
|
||||
template block256(top, number, conv) =
|
||||
if number > high(BlockNumber).u256:
|
||||
top = zero(UInt256)
|
||||
else:
|
||||
conv(k.cpt.getBlockHash(number.truncate(BlockNumber)), top)
|
||||
conv(cpt.getBlockHash(number.truncate(BlockNumber)), top)
|
||||
|
||||
k.cpt.stack.unaryWithTop(block256)
|
||||
cpt.stack.unaryWithTop(block256)
|
||||
|
||||
proc coinBaseOp (k: var VmCtx): EvmResultVoid =
|
||||
proc coinBaseOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x41, Get the block's beneficiary address.
|
||||
k.cpt.stack.push k.cpt.getCoinbase
|
||||
cpt.stack.push cpt.getCoinbase
|
||||
|
||||
proc timestampOp (k: var VmCtx): EvmResultVoid =
|
||||
proc timestampOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x42, Get the block's timestamp.
|
||||
k.cpt.stack.push k.cpt.getTimestamp
|
||||
cpt.stack.push cpt.getTimestamp
|
||||
|
||||
proc blocknumberOp (k: var VmCtx): EvmResultVoid =
|
||||
proc blocknumberOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x43, Get the block's number.
|
||||
k.cpt.stack.push k.cpt.getBlockNumber
|
||||
cpt.stack.push cpt.getBlockNumber
|
||||
|
||||
proc difficultyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc difficultyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x44, Get the block's difficulty
|
||||
k.cpt.stack.push k.cpt.getDifficulty
|
||||
cpt.stack.push cpt.getDifficulty
|
||||
|
||||
proc gasLimitOp (k: var VmCtx): EvmResultVoid =
|
||||
proc gasLimitOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x45, Get the block's gas limit
|
||||
k.cpt.stack.push k.cpt.getGasLimit
|
||||
cpt.stack.push cpt.getGasLimit
|
||||
|
||||
proc chainIdOp (k: var VmCtx): EvmResultVoid =
|
||||
proc chainIdOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x46, Get current chain’s EIP-155 unique identifier.
|
||||
k.cpt.stack.push k.cpt.getChainId
|
||||
cpt.stack.push cpt.getChainId
|
||||
|
||||
proc selfBalanceOp (k: var VmCtx): EvmResultVoid =
|
||||
proc selfBalanceOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x47, Get current contract's balance.
|
||||
let cpt = k.cpt
|
||||
cpt.stack.push cpt.getBalance(cpt.msg.contractAddress)
|
||||
|
||||
proc baseFeeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc baseFeeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x48, Get the block's base fee.
|
||||
k.cpt.stack.push k.cpt.getBaseFee
|
||||
cpt.stack.push cpt.getBaseFee
|
||||
|
||||
proc blobHashOp (k: var VmCtx): EvmResultVoid =
|
||||
proc blobHashOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x49, Get current transaction's EIP-4844 versioned hash.
|
||||
template blob256(top, number, conv) =
|
||||
let
|
||||
index = number.safeInt
|
||||
len = k.cpt.getVersionedHashesLen
|
||||
len = cpt.getVersionedHashesLen
|
||||
|
||||
if index < len:
|
||||
conv(k.cpt.getVersionedHash(index), top)
|
||||
conv(cpt.getVersionedHash(index), top)
|
||||
else:
|
||||
top = zero(UInt256)
|
||||
|
||||
k.cpt.stack.unaryWithTop(blob256)
|
||||
cpt.stack.unaryWithTop(blob256)
|
||||
|
||||
proc blobBaseFeeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc blobBaseFeeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x4a, Get the block's base fee.
|
||||
k.cpt.stack.push k.cpt.getBlobBaseFee
|
||||
cpt.stack.push cpt.getBlobBaseFee
|
||||
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -213,14 +213,12 @@ else:
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc callOp(k: var VmCtx): EvmResultVoid =
|
||||
proc callOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf1, Message-Call into an account
|
||||
let cpt = k.cpt
|
||||
|
||||
if EVMC_STATIC in cpt.msg.flags:
|
||||
let val = ? cpt.stack[^3, UInt256]
|
||||
if val > 0.u256:
|
||||
return err(opErr(StaticContext))
|
||||
let val = ? cpt.stack[^3, UInt256]
|
||||
if val > 0.u256:
|
||||
return err(opErr(StaticContext))
|
||||
|
||||
let
|
||||
p = ? cpt.callParams
|
||||
|
|
@ -292,10 +290,9 @@ proc callOp(k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# ---------------------
|
||||
|
||||
proc callCodeOp(k: var VmCtx): EvmResultVoid =
|
||||
proc callCodeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf2, Message-call into this account with an alternative account's code.
|
||||
let
|
||||
cpt = k.cpt
|
||||
p = ? cpt.callCodeParams
|
||||
(gasCost, childGasLimit) = ? cpt.gasCosts[CallCode].c_handler(
|
||||
p.value,
|
||||
|
|
@ -365,11 +362,10 @@ proc callCodeOp(k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# ---------------------
|
||||
|
||||
proc delegateCallOp(k: var VmCtx): EvmResultVoid =
|
||||
proc delegateCallOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf4, Message-call into this account with an alternative account's
|
||||
## code, but persisting the current values for sender and value.
|
||||
let
|
||||
cpt = k.cpt
|
||||
p = ? cpt.delegateCallParams
|
||||
(gasCost, childGasLimit) = ? cpt.gasCosts[DelegateCall].c_handler(
|
||||
p.value,
|
||||
|
|
@ -433,11 +429,10 @@ proc delegateCallOp(k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# ---------------------
|
||||
|
||||
proc staticCallOp(k: var VmCtx): EvmResultVoid =
|
||||
proc staticCallOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xfa, Static message-call into an account.
|
||||
|
||||
let
|
||||
cpt = k.cpt
|
||||
p = ? cpt.staticCallParams
|
||||
(gasCost, childGasLimit) = ? cpt.gasCosts[StaticCall].c_handler(
|
||||
p.value,
|
||||
|
|
|
|||
|
|
@ -87,13 +87,12 @@ else:
|
|||
# ------------------------------------------------------------------------------
|
||||
|
||||
|
||||
proc createOp(k: var VmCtx): EvmResultVoid =
|
||||
proc createOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf0, Create a new account with associated code
|
||||
? checkInStaticContext(k.cpt)
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.checkInStaticContext()
|
||||
? cpt.stack.lsCheck(3)
|
||||
|
||||
let
|
||||
cpt = k.cpt
|
||||
endowment = cpt.stack.lsPeekInt(^1)
|
||||
memPos = cpt.stack.lsPeekSafeInt(^2)
|
||||
memLen = cpt.stack.lsPeekSafeInt(^3)
|
||||
|
|
@ -167,13 +166,12 @@ proc createOp(k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# ---------------------
|
||||
|
||||
proc create2Op(k: var VmCtx): EvmResultVoid =
|
||||
proc create2Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf5, Behaves identically to CREATE, except using keccak256
|
||||
? checkInStaticContext(k.cpt)
|
||||
? k.cpt.stack.lsCheck(4)
|
||||
? cpt.checkInStaticContext()
|
||||
? cpt.stack.lsCheck(4)
|
||||
|
||||
let
|
||||
cpt = k.cpt
|
||||
endowment = cpt.stack.lsPeekInt(^1)
|
||||
memPos = cpt.stack.lsPeekSafeInt(^2)
|
||||
memLen = cpt.stack.lsPeekSafeInt(^3)
|
||||
|
|
|
|||
|
|
@ -21,12 +21,11 @@ import
|
|||
../op_codes
|
||||
|
||||
type
|
||||
VmCtx* = tuple
|
||||
cpt: Computation ## computation text
|
||||
VmCpt* = Computation ## computation text
|
||||
|
||||
VmOpFn* = ## general op handler, return codes are passed
|
||||
## back via argument descriptor ``k``
|
||||
proc(k: var VmCtx): EvmResultVoid {.nimcall, gcsafe, raises:[].}
|
||||
## back via argument descriptor ``cpt``
|
||||
proc(cpt: VmCpt): EvmResultVoid {.nimcall, gcsafe, raises:[].}
|
||||
|
||||
VmOpExec* = tuple ## op code handler entry
|
||||
opCode: Op ## index back-reference
|
||||
|
|
@ -41,7 +40,7 @@ type
|
|||
|
||||
const
|
||||
VmOpIgnore*: VmOpFn = ## No operation, placeholder function
|
||||
proc(k: var VmCtx): EvmResultVoid = ok()
|
||||
proc(cpt: VmCpt): EvmResultVoid = ok()
|
||||
|
||||
# similar to: toSeq(Fork).mapIt({it}).foldl(a+b)
|
||||
VmOpAllForks* =
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ proc fnInfo(n: int): string {.compileTime.} =
|
|||
"Duplicate " & blurb & " item in the stack"
|
||||
|
||||
|
||||
template dupImpl(k: var VmCtx; n: int): EvmResultVoid =
|
||||
k.cpt.stack.dup(n)
|
||||
template dupImpl(cpt: VmCpt; n: int): EvmResultVoid =
|
||||
cpt.stack.dup(n)
|
||||
|
||||
const
|
||||
inxRange = toSeq(1 .. 16)
|
||||
|
|
|
|||
|
|
@ -35,71 +35,70 @@ when not defined(evmc_enabled):
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc addressOp (k: var VmCtx): EvmResultVoid =
|
||||
proc addressOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x30, Get address of currently executing account.
|
||||
k.cpt.stack.push k.cpt.msg.contractAddress
|
||||
cpt.stack.push cpt.msg.contractAddress
|
||||
|
||||
# ------------------
|
||||
|
||||
proc balanceOp (k: var VmCtx): EvmResultVoid =
|
||||
proc balanceOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x31, Get balance of the given account.
|
||||
template balance256(address): auto =
|
||||
k.cpt.getBalance(address)
|
||||
k.cpt.stack.unaryAddress(balance256)
|
||||
cpt.getBalance(address)
|
||||
cpt.stack.unaryAddress(balance256)
|
||||
|
||||
proc balanceEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc balanceEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x31, EIP292: Get balance of the given account for Berlin and later
|
||||
template balanceEIP2929(address): auto =
|
||||
let gasCost = k.cpt.gasEip2929AccountCheck(address)
|
||||
? k.cpt.opcodeGasCost(Balance, gasCost, reason = "Balance EIP2929")
|
||||
k.cpt.getBalance(address)
|
||||
k.cpt.stack.unaryAddress(balanceEIP2929)
|
||||
let gasCost = cpt.gasEip2929AccountCheck(address)
|
||||
? cpt.opcodeGasCost(Balance, gasCost, reason = "Balance EIP2929")
|
||||
cpt.getBalance(address)
|
||||
cpt.stack.unaryAddress(balanceEIP2929)
|
||||
|
||||
# ------------------
|
||||
|
||||
proc originOp (k: var VmCtx): EvmResultVoid =
|
||||
proc originOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x32, Get execution origination address.
|
||||
k.cpt.stack.push k.cpt.getOrigin()
|
||||
cpt.stack.push cpt.getOrigin()
|
||||
|
||||
proc callerOp (k: var VmCtx): EvmResultVoid =
|
||||
proc callerOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x33, Get caller address.
|
||||
k.cpt.stack.push k.cpt.msg.sender
|
||||
cpt.stack.push cpt.msg.sender
|
||||
|
||||
proc callValueOp (k: var VmCtx): EvmResultVoid =
|
||||
proc callValueOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x34, Get deposited value by the instruction/transaction
|
||||
## responsible for this execution
|
||||
k.cpt.stack.push k.cpt.msg.value
|
||||
cpt.stack.push cpt.msg.value
|
||||
|
||||
proc callDataLoadOp (k: var VmCtx): EvmResultVoid =
|
||||
proc callDataLoadOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x35, Get input data of current environment
|
||||
? k.cpt.stack.lsCheck(1)
|
||||
let start = k.cpt.stack.lsPeekMemRef(^1)
|
||||
? cpt.stack.lsCheck(1)
|
||||
let start = cpt.stack.lsPeekMemRef(^1)
|
||||
|
||||
if start >= k.cpt.msg.data.len:
|
||||
k.cpt.stack.lsTop 0
|
||||
if start >= cpt.msg.data.len:
|
||||
cpt.stack.lsTop 0
|
||||
return ok()
|
||||
|
||||
# If the data does not take 32 bytes, pad with zeros
|
||||
let
|
||||
endRange = min(k.cpt.msg.data.len - 1, start + 31)
|
||||
endRange = min(cpt.msg.data.len - 1, start + 31)
|
||||
presentBytes = endRange - start
|
||||
|
||||
# We rely on value being initialized with 0 by default
|
||||
var value: array[32, byte]
|
||||
assign(value.toOpenArray(0, presentBytes), k.cpt.msg.data.toOpenArray(start, endRange))
|
||||
k.cpt.stack.lsTop value
|
||||
assign(value.toOpenArray(0, presentBytes), cpt.msg.data.toOpenArray(start, endRange))
|
||||
cpt.stack.lsTop value
|
||||
ok()
|
||||
|
||||
proc callDataSizeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc callDataSizeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x36, Get size of input data in current environment.
|
||||
k.cpt.stack.push k.cpt.msg.data.len.u256
|
||||
cpt.stack.push cpt.msg.data.len.u256
|
||||
|
||||
|
||||
proc callDataCopyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc callDataCopyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x37, Copy input data in current environment to memory.
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
copyPos = cpt.stack.lsPeekMemRef(^2)
|
||||
len = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
@ -113,17 +112,15 @@ proc callDataCopyOp (k: var VmCtx): EvmResultVoid =
|
|||
ok()
|
||||
|
||||
|
||||
proc codeSizeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc codeSizeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x38, Get size of code running in current environment.
|
||||
let cpt = k.cpt
|
||||
cpt.stack.push cpt.code.len
|
||||
|
||||
|
||||
proc codeCopyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc codeCopyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x39, Copy code running in current environment to memory.
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
copyPos = cpt.stack.lsPeekMemRef(^2)
|
||||
len = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
@ -136,34 +133,33 @@ proc codeCopyOp (k: var VmCtx): EvmResultVoid =
|
|||
cpt.memory.writePadded(cpt.code.bytes, memPos, copyPos, len)
|
||||
ok()
|
||||
|
||||
proc gasPriceOp (k: var VmCtx): EvmResultVoid =
|
||||
proc gasPriceOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3A, Get price of gas in current environment.
|
||||
k.cpt.stack.push k.cpt.getGasPrice()
|
||||
cpt.stack.push cpt.getGasPrice()
|
||||
|
||||
# -----------
|
||||
|
||||
proc extCodeSizeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeSizeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3b, Get size of an account's code
|
||||
template ecs256(address): auto =
|
||||
k.cpt.getCodeSize(address)
|
||||
k.cpt.stack.unaryAddress(ecs256)
|
||||
cpt.getCodeSize(address)
|
||||
cpt.stack.unaryAddress(ecs256)
|
||||
|
||||
proc extCodeSizeEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeSizeEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3b, Get size of an account's code
|
||||
template ecsEIP2929(address): auto =
|
||||
let gasCost = k.cpt.gasEip2929AccountCheck(address)
|
||||
? k.cpt.opcodeGasCost(ExtCodeSize, gasCost, reason = "ExtCodeSize EIP2929")
|
||||
k.cpt.getCodeSize(address)
|
||||
let gasCost = cpt.gasEip2929AccountCheck(address)
|
||||
? cpt.opcodeGasCost(ExtCodeSize, gasCost, reason = "ExtCodeSize EIP2929")
|
||||
cpt.getCodeSize(address)
|
||||
|
||||
k.cpt.stack.unaryAddress(ecsEIP2929)
|
||||
cpt.stack.unaryAddress(ecsEIP2929)
|
||||
|
||||
# -----------
|
||||
|
||||
proc extCodeCopyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeCopyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3c, Copy an account's code to memory.
|
||||
? k.cpt.stack.lsCheck(4)
|
||||
? cpt.stack.lsCheck(4)
|
||||
let
|
||||
cpt = k.cpt
|
||||
address = cpt.stack.lsPeekAddress(^1)
|
||||
memPos = cpt.stack.lsPeekMemRef(^2)
|
||||
codePos = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
@ -179,11 +175,10 @@ proc extCodeCopyOp (k: var VmCtx): EvmResultVoid =
|
|||
ok()
|
||||
|
||||
|
||||
proc extCodeCopyEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeCopyEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3c, Copy an account's code to memory.
|
||||
? k.cpt.stack.lsCheck(4)
|
||||
? cpt.stack.lsCheck(4)
|
||||
let
|
||||
cpt = k.cpt
|
||||
address = cpt.stack.lsPeekAddress(^1)
|
||||
memPos = cpt.stack.lsPeekMemRef(^2)
|
||||
codePos = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
@ -200,17 +195,16 @@ proc extCodeCopyEIP2929Op (k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# -----------
|
||||
|
||||
proc returnDataSizeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc returnDataSizeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3d, Get size of output data from the previous call from the
|
||||
## current environment.
|
||||
k.cpt.stack.push k.cpt.returnData.len
|
||||
cpt.stack.push cpt.returnData.len
|
||||
|
||||
|
||||
proc returnDataCopyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc returnDataCopyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3e, Copy output data from the previous call to memory.
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
copyPos = cpt.stack.lsPeekMemRef(^2)
|
||||
len = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
@ -227,19 +221,19 @@ proc returnDataCopyOp (k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# ---------------
|
||||
|
||||
proc extCodeHashOp (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeHashOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3f, Returns the keccak256 hash of a contract’s code
|
||||
template ech256(address): auto =
|
||||
k.cpt.getCodeHash(address)
|
||||
k.cpt.stack.unaryAddress(ech256)
|
||||
cpt.getCodeHash(address)
|
||||
cpt.stack.unaryAddress(ech256)
|
||||
|
||||
proc extCodeHashEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc extCodeHashEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x3f, EIP2929: Returns the keccak256 hash of a contract’s code
|
||||
template echEIP2929(address): auto =
|
||||
let gasCost = k.cpt.gasEip2929AccountCheck(address)
|
||||
? k.cpt.opcodeGasCost(ExtCodeHash, gasCost, reason = "ExtCodeHash EIP2929")
|
||||
k.cpt.getCodeHash(address)
|
||||
k.cpt.stack.unaryAddress(echEIP2929)
|
||||
let gasCost = cpt.gasEip2929AccountCheck(address)
|
||||
? cpt.opcodeGasCost(ExtCodeHash, gasCost, reason = "ExtCodeHash EIP2929")
|
||||
cpt.getCodeHash(address)
|
||||
cpt.stack.unaryAddress(echEIP2929)
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# Public, op exec table entries
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@ import
|
|||
|
||||
type
|
||||
OphNumToTextFn* = proc(n: int): string
|
||||
# OpHanldlerImplFn* = proc(k: var VmCtx; n: static int): EvmResultVoid
|
||||
|
||||
const
|
||||
recForkSet = "VmOpAllForks"
|
||||
|
|
@ -48,9 +47,9 @@ macro genOphHandlers*(runHandler: static[OphNumToTextFn];
|
|||
body: untyped): untyped =
|
||||
## Generate the equivalent of
|
||||
## ::
|
||||
## const <runHandler>: VmOpFn = proc (k: var VmCtx) =
|
||||
## const <runHandler>: VmOpFn = proc(cpt: VmCpt) =
|
||||
## ## <itemInfo(n)>,
|
||||
## <body(k,n)>
|
||||
## <body(cpt,n)>
|
||||
##
|
||||
## for all `n` in `inxList`
|
||||
##
|
||||
|
|
@ -61,12 +60,11 @@ macro genOphHandlers*(runHandler: static[OphNumToTextFn];
|
|||
fnName = ident(n.runHandler)
|
||||
comment = newCommentStmtNode(n.itemInfo)
|
||||
|
||||
# => push##Op: VmOpFn = proc (k: var VmCtx) = ...
|
||||
# => push##Op: VmOpFn = proc(cpt: VmCpt) = ...
|
||||
result.add quote do:
|
||||
proc `fnName`(k: var VmCtx): EvmResultVoid =
|
||||
proc `fnName`(cpt: VmCpt): EvmResultVoid =
|
||||
`comment`
|
||||
`body`(k,`n`)
|
||||
# echo ">>>", result.repr
|
||||
`body`(cpt,`n`)
|
||||
|
||||
|
||||
macro genOphList*(runHandler: static[OphNumToTextFn];
|
||||
|
|
@ -83,9 +81,7 @@ macro genOphList*(runHandler: static[OphNumToTextFn];
|
|||
## (opCode: <opCode(n)>,
|
||||
## forks: VmOpAllForks,
|
||||
## info: <handlerInfo(n)>,
|
||||
## exec: (prep: VmOpIgnore,
|
||||
## run: <runHandler(n)>,
|
||||
## post: VmOpIgnore))
|
||||
## exec: <runHandler(n)>)
|
||||
##
|
||||
## for all `n` in `inxList`
|
||||
##
|
||||
|
|
@ -113,7 +109,6 @@ macro genOphList*(runHandler: static[OphNumToTextFn];
|
|||
newIdentNode("VmOpExec")),
|
||||
nnkPrefix.newTree(
|
||||
newIdentNode("@"), records))))
|
||||
# echo ">>> ", result.repr
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
# End
|
||||
|
|
|
|||
|
|
@ -29,11 +29,10 @@ import
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc sha3Op(k: var VmCtx): EvmResultVoid =
|
||||
proc sha3Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x20, Compute Keccak-256 hash.
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
pos = cpt.stack.lsPeekSafeInt(^1)
|
||||
len = cpt.stack.lsPeekSafeInt(^2)
|
||||
cpt.stack.lsShrink(1)
|
||||
|
|
@ -51,7 +50,7 @@ proc sha3Op(k: var VmCtx): EvmResultVoid =
|
|||
if endRange == -1 or pos >= cpt.memory.len:
|
||||
cpt.stack.lsTop(EMPTY_SHA3)
|
||||
else:
|
||||
cpt.stack.lsTop keccakHash k.cpt.memory.bytes.toOpenArray(pos, endRange)
|
||||
cpt.stack.lsTop keccakHash cpt.memory.bytes.toOpenArray(pos, endRange)
|
||||
ok()
|
||||
|
||||
# ------------------------------------------------------------------------------
|
||||
|
|
|
|||
|
|
@ -98,8 +98,8 @@ const
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc wrapperFn(k: var VmCtx; n: static int): EvmResultVoid =
|
||||
logImpl(k.cpt, logOpArg[n], n)
|
||||
proc wrapperFn(cpt: VmCpt; n: static int): EvmResultVoid =
|
||||
cpt.logImpl(logOpArg[n], n)
|
||||
|
||||
genOphHandlers fnName, fnInfo, inxRange, wrapperFn
|
||||
|
||||
|
|
|
|||
|
|
@ -120,19 +120,17 @@ func jumpImpl(c: Computation; jumpTarget: UInt256): EvmResultVoid =
|
|||
# Private, op handlers implementation
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc popOp(k: var VmCtx): EvmResultVoid =
|
||||
proc popOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x50, Remove item from stack.
|
||||
k.cpt.stack.popInt.isOkOr:
|
||||
cpt.stack.popInt.isOkOr:
|
||||
return err(error)
|
||||
ok()
|
||||
|
||||
proc mloadOp (k: var VmCtx): EvmResultVoid =
|
||||
proc mloadOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x51, Load word from memory
|
||||
|
||||
? k.cpt.stack.lsCheck(1)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
? cpt.stack.lsCheck(1)
|
||||
let memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
|
||||
? cpt.opcodeGasCost(Mload,
|
||||
cpt.gasCosts[Mload].m_handler(cpt.memory.len, memPos, 32),
|
||||
|
|
@ -143,11 +141,10 @@ proc mloadOp (k: var VmCtx): EvmResultVoid =
|
|||
ok()
|
||||
|
||||
|
||||
proc mstoreOp (k: var VmCtx): EvmResultVoid =
|
||||
proc mstoreOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x52, Save word to memory
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
value = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -160,11 +157,10 @@ proc mstoreOp (k: var VmCtx): EvmResultVoid =
|
|||
cpt.memory.write(memPos, value.toBytesBE)
|
||||
|
||||
|
||||
proc mstore8Op (k: var VmCtx): EvmResultVoid =
|
||||
proc mstore8Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x53, Save byte to memory
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
memPos = cpt.stack.lsPeekMemRef(^1)
|
||||
value = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -179,27 +175,26 @@ proc mstore8Op (k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# -------
|
||||
|
||||
proc sloadOp (k: var VmCtx): EvmResultVoid =
|
||||
proc sloadOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x54, Load word from storage.
|
||||
template sload256(top, slot, conv) =
|
||||
top = k.cpt.getStorage(slot)
|
||||
k.cpt.stack.unaryWithTop(sload256)
|
||||
top = cpt.getStorage(slot)
|
||||
cpt.stack.unaryWithTop(sload256)
|
||||
|
||||
proc sloadEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc sloadEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x54, EIP2929: Load word from storage for Berlin and later
|
||||
template sloadEIP2929(top, slot, conv) =
|
||||
let gasCost = k.cpt.gasEip2929AccountCheck(k.cpt.msg.contractAddress, slot)
|
||||
? k.cpt.opcodeGasCost(Sload, gasCost, reason = "sloadEIP2929")
|
||||
top = k.cpt.getStorage(slot)
|
||||
k.cpt.stack.unaryWithTop(sloadEIP2929)
|
||||
let gasCost = cpt.gasEip2929AccountCheck(cpt.msg.contractAddress, slot)
|
||||
? cpt.opcodeGasCost(Sload, gasCost, reason = "sloadEIP2929")
|
||||
top = cpt.getStorage(slot)
|
||||
cpt.stack.unaryWithTop(sloadEIP2929)
|
||||
|
||||
# -------
|
||||
|
||||
proc sstoreOp (k: var VmCtx): EvmResultVoid =
|
||||
proc sstoreOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x55, Save word to storage.
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
newValue = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -208,11 +203,10 @@ proc sstoreOp (k: var VmCtx): EvmResultVoid =
|
|||
sstoreEvmcOrSstore(cpt, slot, newValue)
|
||||
|
||||
|
||||
proc sstoreEIP1283Op (k: var VmCtx): EvmResultVoid =
|
||||
proc sstoreEIP1283Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x55, EIP1283: sstore for Constantinople and later
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
newValue = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -221,11 +215,10 @@ proc sstoreEIP1283Op (k: var VmCtx): EvmResultVoid =
|
|||
sstoreEvmcOrNetGasMetering(cpt, slot, newValue)
|
||||
|
||||
|
||||
proc sstoreEIP2200Op (k: var VmCtx): EvmResultVoid =
|
||||
proc sstoreEIP2200Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x55, EIP2200: sstore for Istanbul and later
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
newValue = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -239,11 +232,10 @@ proc sstoreEIP2200Op (k: var VmCtx): EvmResultVoid =
|
|||
sstoreEvmcOrNetGasMetering(cpt, slot, newValue)
|
||||
|
||||
|
||||
proc sstoreEIP2929Op (k: var VmCtx): EvmResultVoid =
|
||||
proc sstoreEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x55, EIP2929: sstore for Berlin and later
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
newValue = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -270,60 +262,58 @@ proc sstoreEIP2929Op (k: var VmCtx): EvmResultVoid =
|
|||
|
||||
# -------
|
||||
|
||||
proc jumpOp (k: var VmCtx): EvmResultVoid =
|
||||
proc jumpOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x56, Alter the program counter
|
||||
let jumpTarget = ? k.cpt.stack.popInt()
|
||||
jumpImpl(k.cpt, jumpTarget)
|
||||
let jumpTarget = ? cpt.stack.popInt()
|
||||
cpt.jumpImpl(jumpTarget)
|
||||
|
||||
|
||||
proc jumpIOp (k: var VmCtx): EvmResultVoid =
|
||||
proc jumpIOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x57, Conditionally alter the program counter.
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
jumpTarget = k.cpt.stack.lsPeekInt(^1)
|
||||
testedValue = k.cpt.stack.lsPeekInt(^2)
|
||||
k.cpt.stack.lsShrink(2)
|
||||
jumpTarget = cpt.stack.lsPeekInt(^1)
|
||||
testedValue = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
||||
if testedValue.isZero:
|
||||
return ok()
|
||||
jumpImpl(k.cpt, jumpTarget)
|
||||
cpt.jumpImpl(jumpTarget)
|
||||
|
||||
proc pcOp (k: var VmCtx): EvmResultVoid =
|
||||
proc pcOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x58, Get the value of the program counter prior to the increment
|
||||
## corresponding to this instruction.
|
||||
k.cpt.stack.push max(k.cpt.code.pc - 1, 0)
|
||||
cpt.stack.push max(cpt.code.pc - 1, 0)
|
||||
|
||||
proc msizeOp (k: var VmCtx): EvmResultVoid =
|
||||
proc msizeOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x59, Get the size of active memory in bytes.
|
||||
k.cpt.stack.push k.cpt.memory.len
|
||||
cpt.stack.push cpt.memory.len
|
||||
|
||||
proc gasOp (k: var VmCtx): EvmResultVoid =
|
||||
proc gasOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5a, Get the amount of available gas, including the corresponding
|
||||
## reduction for the cost of this instruction.
|
||||
k.cpt.stack.push k.cpt.gasMeter.gasRemaining
|
||||
cpt.stack.push cpt.gasMeter.gasRemaining
|
||||
|
||||
proc jumpDestOp (k: var VmCtx): EvmResultVoid =
|
||||
proc jumpDestOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5b, Mark a valid destination for jumps. This operation has no effect
|
||||
## on machine state during execution.
|
||||
ok()
|
||||
|
||||
proc tloadOp (k: var VmCtx): EvmResultVoid =
|
||||
proc tloadOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5c, Load word from transient storage.
|
||||
? k.cpt.stack.lsCheck(1)
|
||||
? cpt.stack.lsCheck(1)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
val = cpt.getTransientStorage(slot)
|
||||
cpt.stack.lsTop val
|
||||
ok()
|
||||
|
||||
proc tstoreOp (k: var VmCtx): EvmResultVoid =
|
||||
proc tstoreOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5d, Save word to transient storage.
|
||||
? checkInStaticContext(k.cpt)
|
||||
? cpt.checkInStaticContext()
|
||||
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
slot = cpt.stack.lsPeekInt(^1)
|
||||
val = cpt.stack.lsPeekInt(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -331,11 +321,10 @@ proc tstoreOp (k: var VmCtx): EvmResultVoid =
|
|||
cpt.setTransientStorage(slot, val)
|
||||
ok()
|
||||
|
||||
proc mCopyOp (k: var VmCtx): EvmResultVoid =
|
||||
proc mCopyOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5e, Copy memory
|
||||
? k.cpt.stack.lsCheck(3)
|
||||
? cpt.stack.lsCheck(3)
|
||||
let
|
||||
cpt = k.cpt
|
||||
dstPos = cpt.stack.lsPeekMemRef(^1)
|
||||
srcPos = cpt.stack.lsPeekMemRef(^2)
|
||||
len = cpt.stack.lsPeekMemRef(^3)
|
||||
|
|
|
|||
|
|
@ -40,8 +40,8 @@ proc fnInfo(n: int): string {.compileTime.} =
|
|||
"Push " & blurb & " on the stack"
|
||||
|
||||
|
||||
template pushImpl(k: var VmCtx; n: static int): EvmResultVoid =
|
||||
k.cpt.stack.push k.cpt.code.readVmWord(n)
|
||||
template pushImpl(cpt: VmCpt; n: static int): EvmResultVoid =
|
||||
cpt.stack.push cpt.code.readVmWord(n)
|
||||
|
||||
const
|
||||
inxRange = toSeq(1 .. 32)
|
||||
|
|
@ -65,9 +65,9 @@ genOphList fnName, fnInfo, inxRange, "VmOpExecPush", opName
|
|||
# about which opcodes are for which forks, but that seems uglier than
|
||||
# just adding Push0 here as a special case.)
|
||||
|
||||
proc push0Op(k: var VmCtx): EvmResultVoid =
|
||||
proc push0Op(cpt: VmCpt): EvmResultVoid =
|
||||
## 0x5f, push 0 onto the stack
|
||||
k.cpt.stack.push(0)
|
||||
cpt.stack.push(0)
|
||||
|
||||
const
|
||||
VmOpExecPushZero*: seq[VmOpExec] = @[
|
||||
|
|
|
|||
|
|
@ -41,8 +41,8 @@ proc fnInfo(n: int): string {.compileTime.} =
|
|||
"Exchange first and " & blurb & " stack items"
|
||||
|
||||
|
||||
template swapImpl(k: var VmCtx; n: static int): EvmResultVoid =
|
||||
k.cpt.stack.swap(n)
|
||||
template swapImpl(cpt: VmCpt; n: static int): EvmResultVoid =
|
||||
cpt.stack.swap(n)
|
||||
|
||||
const
|
||||
inxRange = toSeq(1 .. 16)
|
||||
|
|
|
|||
|
|
@ -37,11 +37,10 @@ when not defined(evmc_enabled):
|
|||
# Private
|
||||
# ------------------------------------------------------------------------------
|
||||
|
||||
proc returnOp(k: var VmCtx): EvmResultVoid =
|
||||
proc returnOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xf3, Halt execution returning output data.
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
pos = cpt.stack.lsPeekMemRef(^1)
|
||||
len = cpt.stack.lsPeekMemRef(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -55,12 +54,11 @@ proc returnOp(k: var VmCtx): EvmResultVoid =
|
|||
ok()
|
||||
|
||||
|
||||
proc revertOp(k: var VmCtx): EvmResultVoid =
|
||||
proc revertOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xfd, Halt execution reverting state changes but returning data
|
||||
## and remaining gas.
|
||||
? k.cpt.stack.lsCheck(2)
|
||||
? cpt.stack.lsCheck(2)
|
||||
let
|
||||
cpt = k.cpt
|
||||
pos = cpt.stack.lsPeekMemRef(^1)
|
||||
len = cpt.stack.lsPeekMemRef(^2)
|
||||
cpt.stack.lsShrink(2)
|
||||
|
|
@ -75,29 +73,24 @@ proc revertOp(k: var VmCtx): EvmResultVoid =
|
|||
cpt.setError(EVMC_REVERT, "REVERT opcode executed", false)
|
||||
ok()
|
||||
|
||||
proc invalidOp(k: var VmCtx): EvmResultVoid =
|
||||
proc invalidOp(cpt: VmCpt): EvmResultVoid =
|
||||
err(opErr(InvalidInstruction))
|
||||
|
||||
# -----------
|
||||
|
||||
proc selfDestructOp(k: var VmCtx): EvmResultVoid =
|
||||
proc selfDestructOp(cpt: VmCpt): EvmResultVoid =
|
||||
## 0xff, Halt execution and register account for later deletion.
|
||||
let
|
||||
cpt = k.cpt
|
||||
beneficiary = ? cpt.stack.popAddress()
|
||||
let beneficiary = ? cpt.stack.popAddress()
|
||||
|
||||
when defined(evmc_enabled):
|
||||
block:
|
||||
cpt.selfDestruct(beneficiary)
|
||||
cpt.selfDestruct(beneficiary)
|
||||
else:
|
||||
block:
|
||||
cpt.selfDestruct(beneficiary)
|
||||
cpt.selfDestruct(beneficiary)
|
||||
ok()
|
||||
|
||||
proc selfDestructEIP150Op(k: var VmCtx): EvmResultVoid =
|
||||
proc selfDestructEIP150Op(cpt: VmCpt): EvmResultVoid =
|
||||
## selfDestructEip150 (auto generated comment)
|
||||
let
|
||||
cpt = k.cpt
|
||||
beneficiary = ? cpt.stack.popAddress()
|
||||
condition = not cpt.accountExists(beneficiary)
|
||||
gasCost = cpt.gasCosts[SelfDestruct].sc_handler(condition)
|
||||
|
|
@ -107,27 +100,25 @@ proc selfDestructEIP150Op(k: var VmCtx): EvmResultVoid =
|
|||
cpt.selfDestruct(beneficiary)
|
||||
ok()
|
||||
|
||||
proc selfDestructEIP161Op(k: var VmCtx): EvmResultVoid =
|
||||
proc selfDestructEIP161Op(cpt: VmCpt): EvmResultVoid =
|
||||
## selfDestructEip161 (auto generated comment)
|
||||
let cpt = k.cpt
|
||||
? checkInStaticContext(cpt)
|
||||
? cpt.checkInStaticContext()
|
||||
|
||||
let
|
||||
beneficiary = ? cpt.stack.popAddress()
|
||||
isDead = not cpt.accountExists(beneficiary)
|
||||
balance = cpt.getBalance(cpt.msg.contractAddress)
|
||||
condition = isDead and not balance.isZero
|
||||
gasCost = cpt.gasCosts[SelfDestruct].sc_handler(condition)
|
||||
isDead = not cpt.accountExists(beneficiary)
|
||||
balance = cpt.getBalance(cpt.msg.contractAddress)
|
||||
condition = isDead and not balance.isZero
|
||||
gasCost = cpt.gasCosts[SelfDestruct].sc_handler(condition)
|
||||
|
||||
? cpt.opcodeGasCost(SelfDestruct,
|
||||
gasCost, reason = "SELFDESTRUCT EIP161")
|
||||
cpt.selfDestruct(beneficiary)
|
||||
ok()
|
||||
|
||||
proc selfDestructEIP2929Op(k: var VmCtx): EvmResultVoid =
|
||||
proc selfDestructEIP2929Op(cpt: VmCpt): EvmResultVoid =
|
||||
## selfDestructEIP2929 (auto generated comment)
|
||||
let cpt = k.cpt
|
||||
? checkInStaticContext(cpt)
|
||||
? cpt.checkInStaticContext()
|
||||
|
||||
let
|
||||
beneficiary = ? cpt.stack.popAddress()
|
||||
|
|
|
|||
|
|
@ -38,10 +38,8 @@ when optimizationCondition:
|
|||
# this is a top level pragma since nim 1.6.16
|
||||
{.optimization: speed.}
|
||||
|
||||
proc selectVM(c: Computation, fork: EVMFork, shouldPrepareTracer: bool): EvmResultVoid =
|
||||
proc selectVM(c: VmCpt, fork: EVMFork, shouldPrepareTracer: bool): EvmResultVoid =
|
||||
## Op code execution handler main loop.
|
||||
var desc: VmCtx
|
||||
desc.cpt = c
|
||||
|
||||
# It's important not to re-prepare the tracer after
|
||||
# an async operation, only after a call/create.
|
||||
|
|
@ -99,12 +97,12 @@ proc selectVM(c: Computation, fork: EVMFork, shouldPrepareTracer: bool): EvmResu
|
|||
else:
|
||||
{.warning: "*** Unsupported OS => no handler switch optimisation".}
|
||||
|
||||
genOptimisedDispatcher(fork, c.instr, desc)
|
||||
genOptimisedDispatcher(fork, c.instr, c)
|
||||
|
||||
else:
|
||||
{.warning: "*** low memory compiler mode => program will be slow".}
|
||||
|
||||
genLowMemDispatcher(fork, c.instr, desc)
|
||||
genLowMemDispatcher(fork, c.instr, c)
|
||||
|
||||
ok()
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue