123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881 |
- // 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 vm
- import (
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/params"
- "github.com/holiman/uint256"
- "golang.org/x/crypto/sha3"
- )
- func opAdd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Add(&x, y)
- return nil, nil
- }
- func opSub(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Sub(&x, y)
- return nil, nil
- }
- func opMul(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Mul(&x, y)
- return nil, nil
- }
- func opDiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Div(&x, y)
- return nil, nil
- }
- func opSdiv(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.SDiv(&x, y)
- return nil, nil
- }
- func opMod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Mod(&x, y)
- return nil, nil
- }
- func opSmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.SMod(&x, y)
- return nil, nil
- }
- func opExp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- base, exponent := scope.Stack.pop(), scope.Stack.peek()
- exponent.Exp(&base, exponent)
- return nil, nil
- }
- func opSignExtend(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- back, num := scope.Stack.pop(), scope.Stack.peek()
- num.ExtendSign(num, &back)
- return nil, nil
- }
- func opNot(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x := scope.Stack.peek()
- x.Not(x)
- return nil, nil
- }
- func opLt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- if x.Lt(y) {
- y.SetOne()
- } else {
- y.Clear()
- }
- return nil, nil
- }
- func opGt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- if x.Gt(y) {
- y.SetOne()
- } else {
- y.Clear()
- }
- return nil, nil
- }
- func opSlt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- if x.Slt(y) {
- y.SetOne()
- } else {
- y.Clear()
- }
- return nil, nil
- }
- func opSgt(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- if x.Sgt(y) {
- y.SetOne()
- } else {
- y.Clear()
- }
- return nil, nil
- }
- func opEq(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- if x.Eq(y) {
- y.SetOne()
- } else {
- y.Clear()
- }
- return nil, nil
- }
- func opIszero(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x := scope.Stack.peek()
- if x.IsZero() {
- x.SetOne()
- } else {
- x.Clear()
- }
- return nil, nil
- }
- func opAnd(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.And(&x, y)
- return nil, nil
- }
- func opOr(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Or(&x, y)
- return nil, nil
- }
- func opXor(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y := scope.Stack.pop(), scope.Stack.peek()
- y.Xor(&x, y)
- return nil, nil
- }
- func opByte(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- th, val := scope.Stack.pop(), scope.Stack.peek()
- val.Byte(&th)
- return nil, nil
- }
- func opAddmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y, z := scope.Stack.pop(), scope.Stack.pop(), scope.Stack.peek()
- if z.IsZero() {
- z.Clear()
- } else {
- z.AddMod(&x, &y, z)
- }
- return nil, nil
- }
- func opMulmod(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x, y, z := scope.Stack.pop(), scope.Stack.pop(), scope.Stack.peek()
- z.MulMod(&x, &y, z)
- return nil, nil
- }
- // opSHL implements Shift Left
- // The SHL instruction (shift left) pops 2 values from the stack, first arg1 and then arg2,
- // and pushes on the stack arg2 shifted to the left by arg1 number of bits.
- func opSHL(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
- shift, value := scope.Stack.pop(), scope.Stack.peek()
- if shift.LtUint64(256) {
- value.Lsh(value, uint(shift.Uint64()))
- } else {
- value.Clear()
- }
- return nil, nil
- }
- // opSHR implements Logical Shift Right
- // The SHR instruction (logical shift right) pops 2 values from the stack, first arg1 and then arg2,
- // and pushes on the stack arg2 shifted to the right by arg1 number of bits with zero fill.
- func opSHR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- // Note, second operand is left in the stack; accumulate result into it, and no need to push it afterwards
- shift, value := scope.Stack.pop(), scope.Stack.peek()
- if shift.LtUint64(256) {
- value.Rsh(value, uint(shift.Uint64()))
- } else {
- value.Clear()
- }
- return nil, nil
- }
- // opSAR implements Arithmetic Shift Right
- // The SAR instruction (arithmetic shift right) pops 2 values from the stack, first arg1 and then arg2,
- // and pushes on the stack arg2 shifted to the right by arg1 number of bits with sign extension.
- func opSAR(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- shift, value := scope.Stack.pop(), scope.Stack.peek()
- if shift.GtUint64(256) {
- if value.Sign() >= 0 {
- value.Clear()
- } else {
- // Max negative shift: all bits set
- value.SetAllOne()
- }
- return nil, nil
- }
- n := uint(shift.Uint64())
- value.SRsh(value, n)
- return nil, nil
- }
- func opSha3(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- offset, size := scope.Stack.pop(), scope.Stack.peek()
- data := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
- if interpreter.hasher == nil {
- interpreter.hasher = sha3.NewLegacyKeccak256().(keccakState)
- } else {
- interpreter.hasher.Reset()
- }
- interpreter.hasher.Write(data)
- interpreter.hasher.Read(interpreter.hasherBuf[:])
- evm := interpreter.evm
- if evm.vmConfig.EnablePreimageRecording {
- evm.StateDB.AddPreimage(interpreter.hasherBuf, data)
- }
- size.SetBytes(interpreter.hasherBuf[:])
- return nil, nil
- }
- func opAddress(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Address().Bytes()))
- return nil, nil
- }
- func opBalance(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- slot := scope.Stack.peek()
- address := common.Address(slot.Bytes20())
- slot.SetFromBig(getDualState(interpreter.evm, address).GetBalance(address)) // Quorum: get public/private state db based on addr
- return nil, nil
- }
- func opOrigin(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetBytes(interpreter.evm.Origin.Bytes()))
- return nil, nil
- }
- func opCaller(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetBytes(scope.Contract.Caller().Bytes()))
- return nil, nil
- }
- func opCallValue(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v, _ := uint256.FromBig(scope.Contract.value)
- scope.Stack.push(v)
- return nil, nil
- }
- func opCallDataLoad(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- x := scope.Stack.peek()
- if offset, overflow := x.Uint64WithOverflow(); !overflow {
- data := getData(scope.Contract.Input, offset, 32)
- x.SetBytes(data)
- } else {
- x.Clear()
- }
- return nil, nil
- }
- func opCallDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(scope.Contract.Input))))
- return nil, nil
- }
- func opCallDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- memOffset = scope.Stack.pop()
- dataOffset = scope.Stack.pop()
- length = scope.Stack.pop()
- )
- dataOffset64, overflow := dataOffset.Uint64WithOverflow()
- if overflow {
- dataOffset64 = 0xffffffffffffffff
- }
- // These values are checked for overflow during gas cost calculation
- memOffset64 := memOffset.Uint64()
- length64 := length.Uint64()
- scope.Memory.Set(memOffset64, length64, getData(scope.Contract.Input, dataOffset64, length64))
- return nil, nil
- }
- func opReturnDataSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(uint64(len(interpreter.returnData))))
- return nil, nil
- }
- func opReturnDataCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- memOffset = scope.Stack.pop()
- dataOffset = scope.Stack.pop()
- length = scope.Stack.pop()
- )
- offset64, overflow := dataOffset.Uint64WithOverflow()
- if overflow {
- return nil, ErrReturnDataOutOfBounds
- }
- // we can reuse dataOffset now (aliasing it for clarity)
- var end = dataOffset
- end.Add(&dataOffset, &length)
- end64, overflow := end.Uint64WithOverflow()
- if overflow || uint64(len(interpreter.returnData)) < end64 {
- return nil, ErrReturnDataOutOfBounds
- }
- scope.Memory.Set(memOffset.Uint64(), length.Uint64(), interpreter.returnData[offset64:end64])
- return nil, nil
- }
- func opExtCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- slot := scope.Stack.peek()
- addr := slot.Bytes20()
- // Quorum: get public/private state db based on addr
- slot.SetUint64(uint64(getDualState(interpreter.evm, addr).GetCodeSize(slot.Bytes20()))) // Quorum: get public/private state db based on addr
- return nil, nil
- }
- func opCodeSize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- l := new(uint256.Int)
- l.SetUint64(uint64(len(scope.Contract.Code)))
- scope.Stack.push(l)
- return nil, nil
- }
- func opCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- memOffset = scope.Stack.pop()
- codeOffset = scope.Stack.pop()
- length = scope.Stack.pop()
- )
- uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
- if overflow {
- uint64CodeOffset = 0xffffffffffffffff
- }
- codeCopy := getData(scope.Contract.Code, uint64CodeOffset, length.Uint64())
- scope.Memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
- return nil, nil
- }
- func opExtCodeCopy(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- stack = scope.Stack
- a = stack.pop()
- memOffset = stack.pop()
- codeOffset = stack.pop()
- length = stack.pop()
- )
- uint64CodeOffset, overflow := codeOffset.Uint64WithOverflow()
- if overflow {
- uint64CodeOffset = 0xffffffffffffffff
- }
- addr := common.Address(a.Bytes20())
- codeCopy := getData(getDualState(interpreter.evm, addr).GetCode(addr), uint64CodeOffset, length.Uint64()) // Quorum: get public/private state db based on addr
- scope.Memory.Set(memOffset.Uint64(), length.Uint64(), codeCopy)
- return nil, nil
- }
- // opExtCodeHash returns the code hash of a specified account.
- // There are several cases when the function is called, while we can relay everything
- // to `state.GetCodeHash` function to ensure the correctness.
- // (1) Caller tries to get the code hash of a normal contract account, state
- // should return the relative code hash and set it as the result.
- //
- // (2) Caller tries to get the code hash of a non-existent account, state should
- // return common.Hash{} and zero will be set as the result.
- //
- // (3) Caller tries to get the code hash for an account without contract code,
- // state should return emptyCodeHash(0xc5d246...) as the result.
- //
- // (4) Caller tries to get the code hash of a precompiled account, the result
- // should be zero or emptyCodeHash.
- //
- // It is worth noting that in order to avoid unnecessary create and clean,
- // all precompile accounts on mainnet have been transferred 1 wei, so the return
- // here should be emptyCodeHash.
- // If the precompile account is not transferred any amount on a private or
- // customized chain, the return value will be zero.
- //
- // (5) Caller tries to get the code hash for an account which is marked as suicided
- // in the current transaction, the code hash of this account should be returned.
- //
- // (6) Caller tries to get the code hash for an account which is marked as deleted,
- // this account should be regarded as a non-existent account and zero should be returned.
- func opExtCodeHash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- slot := scope.Stack.peek()
- address := common.Address(slot.Bytes20())
- stateDB := getDualState(interpreter.evm, address)
- if stateDB.Empty(address) {
- slot.Clear()
- } else {
- slot.SetBytes(stateDB.GetCodeHash(address).Bytes())
- }
- return nil, nil
- }
- func opGasprice(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v, _ := uint256.FromBig(interpreter.evm.GasPrice)
- scope.Stack.push(v)
- return nil, nil
- }
- func opBlockhash(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- num := scope.Stack.peek()
- num64, overflow := num.Uint64WithOverflow()
- if overflow {
- num.Clear()
- return nil, nil
- }
- var upper, lower uint64
- upper = interpreter.evm.Context.BlockNumber.Uint64()
- if upper < 257 {
- lower = 0
- } else {
- lower = upper - 256
- }
- if num64 >= lower && num64 < upper {
- num.SetBytes(interpreter.evm.Context.GetHash(num64).Bytes())
- } else {
- num.Clear()
- }
- return nil, nil
- }
- func opCoinbase(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetBytes(interpreter.evm.Context.Coinbase.Bytes()))
- return nil, nil
- }
- func opTimestamp(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v, _ := uint256.FromBig(interpreter.evm.Context.Time)
- scope.Stack.push(v)
- return nil, nil
- }
- func opNumber(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v, _ := uint256.FromBig(interpreter.evm.Context.BlockNumber)
- scope.Stack.push(v)
- return nil, nil
- }
- func opDifficulty(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v, _ := uint256.FromBig(interpreter.evm.Context.Difficulty)
- scope.Stack.push(v)
- return nil, nil
- }
- func opGasLimit(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(interpreter.evm.Context.GasLimit))
- return nil, nil
- }
- func opPop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.pop()
- return nil, nil
- }
- func opMload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- v := scope.Stack.peek()
- offset := int64(v.Uint64())
- v.SetBytes(scope.Memory.GetPtr(offset, 32))
- return nil, nil
- }
- func opMstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- // pop value of the stack
- mStart, val := scope.Stack.pop(), scope.Stack.pop()
- scope.Memory.Set32(mStart.Uint64(), &val)
- return nil, nil
- }
- func opMstore8(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- off, val := scope.Stack.pop(), scope.Stack.pop()
- scope.Memory.store[off.Uint64()] = byte(val.Uint64())
- return nil, nil
- }
- func opSload(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- loc := scope.Stack.peek()
- hash := common.Hash(loc.Bytes32())
- val := getDualState(interpreter.evm, scope.Contract.Address()).GetState(scope.Contract.Address(), hash) // Quorum: get public/private state db based on addr
- loc.SetBytes(val.Bytes())
- return nil, nil
- }
- func opSstore(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- loc := scope.Stack.pop()
- val := scope.Stack.pop()
- // Quorum: get public/private state db based on addr
- getDualState(interpreter.evm, scope.Contract.Address()).SetState(scope.Contract.Address(),
- loc.Bytes32(), val.Bytes32())
- return nil, nil
- }
- func opJump(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- pos := scope.Stack.pop()
- if !scope.Contract.validJumpdest(&pos) {
- return nil, ErrInvalidJump
- }
- *pc = pos.Uint64()
- return nil, nil
- }
- func opJumpi(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- pos, cond := scope.Stack.pop(), scope.Stack.pop()
- if !cond.IsZero() {
- if !scope.Contract.validJumpdest(&pos) {
- return nil, ErrInvalidJump
- }
- *pc = pos.Uint64()
- } else {
- *pc++
- }
- return nil, nil
- }
- func opJumpdest(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- return nil, nil
- }
- func opPc(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(*pc))
- return nil, nil
- }
- func opMsize(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(uint64(scope.Memory.Len())))
- return nil, nil
- }
- func opGas(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.push(new(uint256.Int).SetUint64(scope.Contract.Gas))
- return nil, nil
- }
- func opCreate(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- value = scope.Stack.pop()
- offset, size = scope.Stack.pop(), scope.Stack.pop()
- input = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
- gas = scope.Contract.Gas
- )
- if interpreter.evm.chainRules.IsEIP150 {
- gas -= gas / 64
- }
- // reuse size int for stackvalue
- stackvalue := size
- scope.Contract.UseGas(gas)
- //TODO: use uint256.Int instead of converting with toBig()
- var bigVal = big0
- if !value.IsZero() {
- bigVal = value.ToBig()
- }
- res, addr, returnGas, suberr := interpreter.evm.Create(scope.Contract, input, gas, bigVal)
- // Push item on the stack based on the returned error. If the ruleset is
- // homestead we must check for CodeStoreOutOfGasError (homestead only
- // rule) and treat as an error, if the ruleset is frontier we must
- // ignore this error and pretend the operation was successful.
- if interpreter.evm.chainRules.IsHomestead && suberr == ErrCodeStoreOutOfGas {
- stackvalue.Clear()
- } else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
- stackvalue.Clear()
- } else {
- stackvalue.SetBytes(addr.Bytes())
- }
- scope.Stack.push(&stackvalue)
- scope.Contract.Gas += returnGas
- if suberr == ErrExecutionReverted {
- return res, nil
- }
- return nil, nil
- }
- func opCreate2(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- endowment = scope.Stack.pop()
- offset, size = scope.Stack.pop(), scope.Stack.pop()
- salt = scope.Stack.pop()
- input = scope.Memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
- gas = scope.Contract.Gas
- )
- // Apply EIP150
- gas -= gas / 64
- scope.Contract.UseGas(gas)
- // reuse size int for stackvalue
- stackvalue := size
- //TODO: use uint256.Int instead of converting with toBig()
- bigEndowment := big0
- if !endowment.IsZero() {
- bigEndowment = endowment.ToBig()
- }
- res, addr, returnGas, suberr := interpreter.evm.Create2(scope.Contract, input, gas,
- bigEndowment, &salt)
- // Push item on the stack based on the returned error.
- if suberr != nil {
- stackvalue.Clear()
- } else {
- stackvalue.SetBytes(addr.Bytes())
- }
- scope.Stack.push(&stackvalue)
- scope.Contract.Gas += returnGas
- if suberr == ErrExecutionReverted {
- return res, nil
- }
- return nil, nil
- }
- func opCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- stack := scope.Stack
- // Pop gas. The actual gas in interpreter.evm.callGasTemp.
- // We can use this as a temporary value
- temp := stack.pop()
- gas := interpreter.evm.callGasTemp
- // Pop other call parameters.
- addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
- toAddr := common.Address(addr.Bytes20())
- // Get the arguments from the memory.
- args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
- var bigVal = big0
- //TODO: use uint256.Int instead of converting with toBig()
- // By using big0 here, we save an alloc for the most common case (non-ether-transferring contract calls),
- // but it would make more sense to extend the usage of uint256.Int
- if !value.IsZero() {
- gas += params.CallStipend
- bigVal = value.ToBig()
- }
- ret, returnGas, err := interpreter.evm.Call(scope.Contract, toAddr, args, gas, bigVal)
- if err != nil {
- temp.Clear()
- } else {
- temp.SetOne()
- }
- stack.push(&temp)
- if err == nil || err == ErrExecutionReverted {
- scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
- }
- scope.Contract.Gas += returnGas
- return ret, nil
- }
- func opCallCode(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- stack := scope.Stack
- // We use it as a temporary value
- temp := stack.pop()
- gas := interpreter.evm.callGasTemp
- // Pop other call parameters.
- addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
- toAddr := common.Address(addr.Bytes20())
- // Get arguments from the memory.
- args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
- //TODO: use uint256.Int instead of converting with toBig()
- var bigVal = big0
- if !value.IsZero() {
- gas += params.CallStipend
- bigVal = value.ToBig()
- }
- ret, returnGas, err := interpreter.evm.CallCode(scope.Contract, toAddr, args, gas, bigVal)
- if err != nil {
- temp.Clear()
- } else {
- temp.SetOne()
- }
- stack.push(&temp)
- if err == nil || err == ErrExecutionReverted {
- scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
- }
- scope.Contract.Gas += returnGas
- return ret, nil
- }
- func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- stack := scope.Stack
- // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- // We use it as a temporary value
- temp := stack.pop()
- gas := interpreter.evm.callGasTemp
- // Pop other call parameters.
- addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
- toAddr := common.Address(addr.Bytes20())
- // Get arguments from the memory.
- args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
- ret, returnGas, err := interpreter.evm.DelegateCall(scope.Contract, toAddr, args, gas)
- if err != nil {
- temp.Clear()
- } else {
- temp.SetOne()
- }
- stack.push(&temp)
- if err == nil || err == ErrExecutionReverted {
- scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
- }
- scope.Contract.Gas += returnGas
- return ret, nil
- }
- func opStaticCall(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- // Pop gas. The actual gas is in interpreter.evm.callGasTemp.
- stack := scope.Stack
- // We use it as a temporary value
- temp := stack.pop()
- gas := interpreter.evm.callGasTemp
- // Pop other call parameters.
- addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
- toAddr := common.Address(addr.Bytes20())
- // Get arguments from the memory.
- args := scope.Memory.GetPtr(int64(inOffset.Uint64()), int64(inSize.Uint64()))
- ret, returnGas, err := interpreter.evm.StaticCall(scope.Contract, toAddr, args, gas)
- if err != nil {
- temp.Clear()
- } else {
- temp.SetOne()
- }
- stack.push(&temp)
- if err == nil || err == ErrExecutionReverted {
- scope.Memory.Set(retOffset.Uint64(), retSize.Uint64(), ret)
- }
- scope.Contract.Gas += returnGas
- return ret, nil
- }
- func opReturn(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- offset, size := scope.Stack.pop(), scope.Stack.pop()
- ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
- return ret, nil
- }
- func opRevert(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- offset, size := scope.Stack.pop(), scope.Stack.pop()
- ret := scope.Memory.GetPtr(int64(offset.Uint64()), int64(size.Uint64()))
- return ret, nil
- }
- func opStop(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- return nil, nil
- }
- func opSuicide(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- beneficiary := scope.Stack.pop()
- // Quorum: get public/private state db based on addr
- db := getDualState(interpreter.evm, scope.Contract.Address())
- balance := db.GetBalance(scope.Contract.Address())
- db.AddBalance(beneficiary.Bytes20(), balance)
- db.Suicide(scope.Contract.Address())
- return nil, nil
- }
- // following functions are used by the instruction jump table
- // make log instruction function
- func makeLog(size int) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- topics := make([]common.Hash, size)
- stack := scope.Stack
- mStart, mSize := stack.pop(), stack.pop()
- for i := 0; i < size; i++ {
- addr := stack.pop()
- topics[i] = addr.Bytes32()
- }
- d := scope.Memory.GetCopy(int64(mStart.Uint64()), int64(mSize.Uint64()))
- interpreter.evm.StateDB.AddLog(&types.Log{
- Address: scope.Contract.Address(),
- Topics: topics,
- Data: d,
- // This is a non-consensus field, but assigned here because
- // core/state doesn't know the current block number.
- BlockNumber: interpreter.evm.Context.BlockNumber.Uint64(),
- })
- return nil, nil
- }
- }
- // opPush1 is a specialized version of pushN
- func opPush1(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- var (
- codeLen = uint64(len(scope.Contract.Code))
- integer = new(uint256.Int)
- )
- *pc += 1
- if *pc < codeLen {
- scope.Stack.push(integer.SetUint64(uint64(scope.Contract.Code[*pc])))
- } else {
- scope.Stack.push(integer.Clear())
- }
- return nil, nil
- }
- // make push instruction function
- func makePush(size uint64, pushByteSize int) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- codeLen := len(scope.Contract.Code)
- startMin := codeLen
- if int(*pc+1) < startMin {
- startMin = int(*pc + 1)
- }
- endMin := codeLen
- if startMin+pushByteSize < endMin {
- endMin = startMin + pushByteSize
- }
- integer := new(uint256.Int)
- scope.Stack.push(integer.SetBytes(common.RightPadBytes(
- scope.Contract.Code[startMin:endMin], pushByteSize)))
- *pc += size
- return nil, nil
- }
- }
- // make dup instruction function
- func makeDup(size int64) executionFunc {
- return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.dup(int(size))
- return nil, nil
- }
- }
- // make swap instruction function
- func makeSwap(size int64) executionFunc {
- // switch n + 1 otherwise n would be swapped with n
- size++
- return func(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
- scope.Stack.swap(int(size))
- return nil, nil
- }
- }
|