mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

core/vm: implement RETURNDATA metropolis opcodes

Browse Source
pull/14981/head
Jeffrey Wilcke 7 years ago committed by Péter Szilágyi
parent 76069eef38
commit 9bd6068fef
No known key found for this signature in database
GPG Key ID: E9AE538CEDF8293D
6 changed files with 253 additions and 171 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 26
      core/vm/gas_table.go
  2. 23
      core/vm/instructions.go
  3. 14
      core/vm/interpreter.go
  4. 50
      core/vm/jump_table.go
  5. 4
      core/vm/memory_table.go
  6. 307
      core/vm/opcodes.go

26
core/vm/gas_table.go
Unescape View File

@ -91,6 +91,32 @@ func gasCalldataCopy(gt params.GasTable, evm *EVM, contract *Contract, stack *St
return gas, nil return gas, nil
} }
func gasReturnDataCopy(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
gas, err := memoryGasCost(mem, memorySize)
if err != nil {
return 0, err
}
var overflow bool
if gas, overflow = math.SafeAdd(gas, GasFastestStep); overflow {
return 0, errGasUintOverflow
}
words, overflow := bigUint64(stack.Back(2))
if overflow {
return 0, errGasUintOverflow
}
if words, overflow = math.SafeMul(toWordSize(words), params.CopyGas); overflow {
return 0, errGasUintOverflow
}
if gas, overflow = math.SafeAdd(gas, words); overflow {
return 0, errGasUintOverflow
}
return gas, nil
}
func gasSStore(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) { func gasSStore(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
var ( var (
y, x = stack.Back(1), stack.Back(0) y, x = stack.Back(1), stack.Back(0)

23
core/vm/instructions.go
Unescape View File

@ -31,6 +31,7 @@ import (
var ( var (
bigZero = new(big.Int) bigZero = new(big.Int)
errWriteProtection = errors.New("evm: write protection") errWriteProtection = errors.New("evm: write protection")
errReadOutOfBound = errors.New("evm: read out of bound")
) )
func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
@ -360,6 +361,28 @@ func opCalldataCopy(pc *uint64, evm *EVM, contract *Contract, memory *Memory, st
return nil, nil return nil, nil
} }
func opReturnDataSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
stack.push(evm.interpreter.intPool.get().SetUint64(uint64(len(evm.interpreter.returnData))))
return nil, nil
}
func opReturnDataCopy(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
var (
mOff = stack.pop()
cOff = stack.pop()
l = stack.pop()
)
defer evm.interpreter.intPool.put(mOff, cOff, l)
cEnd := new(big.Int).Add(cOff, l)
if cEnd.BitLen() > 64 || uint64(len(evm.interpreter.returnData)) < cEnd.Uint64() {
return nil, errReadOutOfBound
}
memory.Set(mOff.Uint64(), l.Uint64(), evm.interpreter.returnData[cOff.Uint64():cEnd.Uint64()])
return nil, nil
}
func opExtCodeSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { func opExtCodeSize(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
a := stack.pop() a := stack.pop()

14
core/vm/interpreter.go
Unescape View File

@ -60,6 +60,8 @@ type Interpreter struct {
intPool *intPool intPool *intPool
readonly bool readonly bool
// returnData contains the last call's return data
returnData []byte
} }
// NewInterpreter returns a new instance of the Interpreter. // NewInterpreter returns a new instance of the Interpreter.
@ -113,6 +115,10 @@ func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret
in.evm.depth++ in.evm.depth++
defer func() { in.evm.depth-- }() defer func() { in.evm.depth-- }()
// Reset the previous call's return data. It's unimportant to preserve the old buffer
// as every returning call will return new data anyway.
in.returnData = nil
// Don't bother with the execution if there's no code. // Don't bother with the execution if there's no code.
if len(contract.Code) == 0 { if len(contract.Code) == 0 {
return nil, nil return nil, nil
@ -213,10 +219,10 @@ func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret
case !operation.jumps: case !operation.jumps:
pc++ pc++
} }
// if the operation returned a value make sure that is also set // if the operation clears the return data (e.g. it has returning data)
// the last return data. // set the last return to the result of the operation.
if res != nil { if operation.clearsReturndata {
mem.lastReturn = ret in.returnData = res
} }
} }
return nil, nil return nil, nil

50
core/vm/jump_table.go
Unescape View File

@ -53,6 +53,8 @@ type operation struct {
valid bool valid bool
// reverts determined whether the operation reverts state // reverts determined whether the operation reverts state
reverts bool reverts bool
// clearsReturndata determines whether the opertions clears the return data
clearsReturndata bool
} }
var ( var (
@ -73,6 +75,19 @@ func NewMetropolisInstructionSet() [256]operation {
memorySize: memoryStaticCall, memorySize: memoryStaticCall,
valid: true, valid: true,
} }
instructionSet[RETURNDATASIZE] = operation{
execute: opReturnDataSize,
gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1),
valid: true,
}
instructionSet[RETURNDATACOPY] = operation{
execute: opReturnDataCopy,
gasCost: gasReturnDataCopy,
validateStack: makeStackFunc(3, 0),
memorySize: memoryReturnDataCopy,
valid: true,
}
return instructionSet return instructionSet
} }
@ -861,26 +876,29 @@ func NewFrontierInstructionSet() [256]operation {
writes: true, writes: true,
}, },
CREATE: { CREATE: {
execute: opCreate, execute: opCreate,
gasCost: gasCreate, gasCost: gasCreate,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
memorySize: memoryCreate, memorySize: memoryCreate,
valid: true, valid: true,
writes: true, writes: true,
clearsReturndata: true,
}, },
CALL: { CALL: {
execute: opCall, execute: opCall,
gasCost: gasCall, gasCost: gasCall,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
clearsReturndata: true,
}, },
CALLCODE: { CALLCODE: {
execute: opCallCode, execute: opCallCode,
gasCost: gasCallCode, gasCost: gasCallCode,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
clearsReturndata: true,
}, },
RETURN: { RETURN: {
execute: opReturn, execute: opReturn,

4
core/vm/memory_table.go
Unescape View File

@ -30,6 +30,10 @@ func memoryCalldataCopy(stack *Stack) *big.Int {
return calcMemSize(stack.Back(0), stack.Back(2)) return calcMemSize(stack.Back(0), stack.Back(2))
} }
func memoryReturnDataCopy(stack *Stack) *big.Int {
return calcMemSize(stack.Back(0), stack.Back(2))
}
func memoryCodeCopy(stack *Stack) *big.Int { func memoryCodeCopy(stack *Stack) *big.Int {
return calcMemSize(stack.Back(0), stack.Back(2)) return calcMemSize(stack.Back(0), stack.Back(2))
} }

307
core/vm/opcodes.go
Unescape View File

@ -82,10 +82,11 @@ const (
GASPRICE GASPRICE
EXTCODESIZE EXTCODESIZE
EXTCODECOPY EXTCODECOPY
RETURNDATASIZE
RETURNDATACOPY
) )
const ( const (
// 0x40 range - block operations // 0x40 range - block operations
BLOCKHASH OpCode = 0x40 + iota BLOCKHASH OpCode = 0x40 + iota
COINBASE COINBASE
@ -239,27 +240,29 @@ var opCodeToString = map[OpCode]string{
SHA3: "SHA3", SHA3: "SHA3",
// 0x30 range - closure state // 0x30 range - closure state
ADDRESS: "ADDRESS", ADDRESS: "ADDRESS",
BALANCE: "BALANCE", BALANCE: "BALANCE",
ORIGIN: "ORIGIN", ORIGIN: "ORIGIN",
CALLER: "CALLER", CALLER: "CALLER",
CALLVALUE: "CALLVALUE", CALLVALUE: "CALLVALUE",
CALLDATALOAD: "CALLDATALOAD", CALLDATALOAD: "CALLDATALOAD",
CALLDATASIZE: "CALLDATASIZE", CALLDATASIZE: "CALLDATASIZE",
CALLDATACOPY: "CALLDATACOPY", CALLDATACOPY: "CALLDATACOPY",
CODESIZE: "CODESIZE", CODESIZE: "CODESIZE",
CODECOPY: "CODECOPY", CODECOPY: "CODECOPY",
GASPRICE: "GASPRICE", GASPRICE: "GASPRICE",
EXTCODESIZE: "EXTCODESIZE",
EXTCODECOPY: "EXTCODECOPY",
RETURNDATASIZE: "RETURNDATASIZE",
RETURNDATACOPY: "RETURNDATACOPY",
// 0x40 range - block operations // 0x40 range - block operations
BLOCKHASH: "BLOCKHASH", BLOCKHASH: "BLOCKHASH",
COINBASE: "COINBASE", COINBASE: "COINBASE",
TIMESTAMP: "TIMESTAMP", TIMESTAMP: "TIMESTAMP",
NUMBER: "NUMBER", NUMBER: "NUMBER",
DIFFICULTY: "DIFFICULTY", DIFFICULTY: "DIFFICULTY",
GASLIMIT: "GASLIMIT", GASLIMIT: "GASLIMIT",
EXTCODESIZE: "EXTCODESIZE",
EXTCODECOPY: "EXTCODECOPY",
// 0x50 range - 'storage' and execution // 0x50 range - 'storage' and execution
POP: "POP", POP: "POP",
@ -374,137 +377,139 @@ func (o OpCode) String() string {
} }
var stringToOp = map[string]OpCode{ var stringToOp = map[string]OpCode{
"STOP": STOP, "STOP": STOP,
"ADD": ADD, "ADD": ADD,
"MUL": MUL, "MUL": MUL,
"SUB": SUB, "SUB": SUB,
"DIV": DIV, "DIV": DIV,
"SDIV": SDIV, "SDIV": SDIV,
"MOD": MOD, "MOD": MOD,
"SMOD": SMOD, "SMOD": SMOD,
"EXP": EXP, "EXP": EXP,
"NOT": NOT, "NOT": NOT,
"LT": LT, "LT": LT,
"GT": GT, "GT": GT,
"SLT": SLT, "SLT": SLT,
"SGT": SGT, "SGT": SGT,
"EQ": EQ, "EQ": EQ,
"ISZERO": ISZERO, "ISZERO": ISZERO,
"SIGNEXTEND": SIGNEXTEND, "SIGNEXTEND": SIGNEXTEND,
"AND": AND, "AND": AND,
"OR": OR, "OR": OR,
"XOR": XOR, "XOR": XOR,
"BYTE": BYTE, "BYTE": BYTE,
"ADDMOD": ADDMOD, "ADDMOD": ADDMOD,
"MULMOD": MULMOD, "MULMOD": MULMOD,
"SHA3": SHA3, "SHA3": SHA3,
"ADDRESS": ADDRESS, "ADDRESS": ADDRESS,
"BALANCE": BALANCE, "BALANCE": BALANCE,
"ORIGIN": ORIGIN, "ORIGIN": ORIGIN,
"CALLER": CALLER, "CALLER": CALLER,
"CALLVALUE": CALLVALUE, "CALLVALUE": CALLVALUE,
"CALLDATALOAD": CALLDATALOAD, "CALLDATALOAD": CALLDATALOAD,
"CALLDATASIZE": CALLDATASIZE, "CALLDATASIZE": CALLDATASIZE,
"CALLDATACOPY": CALLDATACOPY, "CALLDATACOPY": CALLDATACOPY,
"DELEGATECALL": DELEGATECALL, "DELEGATECALL": DELEGATECALL,
"STATICCALL": STATICCALL, "STATICCALL": STATICCALL,
"CODESIZE": CODESIZE, "CODESIZE": CODESIZE,
"CODECOPY": CODECOPY, "CODECOPY": CODECOPY,
"GASPRICE": GASPRICE, "GASPRICE": GASPRICE,
"BLOCKHASH": BLOCKHASH, "EXTCODESIZE": EXTCODESIZE,
"COINBASE": COINBASE, "EXTCODECOPY": EXTCODECOPY,
"TIMESTAMP": TIMESTAMP, "RETURNDATASIZE": RETURNDATASIZE,
"NUMBER": NUMBER, "RETURNDATACOPY": RETURNDATACOPY,
"DIFFICULTY": DIFFICULTY, "BLOCKHASH": BLOCKHASH,
"GASLIMIT": GASLIMIT, "COINBASE": COINBASE,
"EXTCODESIZE": EXTCODESIZE, "TIMESTAMP": TIMESTAMP,
"EXTCODECOPY": EXTCODECOPY, "NUMBER": NUMBER,
"POP": POP, "DIFFICULTY": DIFFICULTY,
"MLOAD": MLOAD, "GASLIMIT": GASLIMIT,
"MSTORE": MSTORE, "POP": POP,
"MSTORE8": MSTORE8, "MLOAD": MLOAD,
"SLOAD": SLOAD, "MSTORE": MSTORE,
"SSTORE": SSTORE, "MSTORE8": MSTORE8,
"JUMP": JUMP, "SLOAD": SLOAD,
"JUMPI": JUMPI, "SSTORE": SSTORE,
"PC": PC, "JUMP": JUMP,
"MSIZE": MSIZE, "JUMPI": JUMPI,
"GAS": GAS, "PC": PC,
"JUMPDEST": JUMPDEST, "MSIZE": MSIZE,
"PUSH1": PUSH1, "GAS": GAS,
"PUSH2": PUSH2, "JUMPDEST": JUMPDEST,
"PUSH3": PUSH3, "PUSH1": PUSH1,
"PUSH4": PUSH4, "PUSH2": PUSH2,
"PUSH5": PUSH5, "PUSH3": PUSH3,
"PUSH6": PUSH6, "PUSH4": PUSH4,
"PUSH7": PUSH7, "PUSH5": PUSH5,
"PUSH8": PUSH8, "PUSH6": PUSH6,
"PUSH9": PUSH9, "PUSH7": PUSH7,
"PUSH10": PUSH10, "PUSH8": PUSH8,
"PUSH11": PUSH11, "PUSH9": PUSH9,
"PUSH12": PUSH12, "PUSH10": PUSH10,
"PUSH13": PUSH13, "PUSH11": PUSH11,
"PUSH14": PUSH14, "PUSH12": PUSH12,
"PUSH15": PUSH15, "PUSH13": PUSH13,
"PUSH16": PUSH16, "PUSH14": PUSH14,
"PUSH17": PUSH17, "PUSH15": PUSH15,
"PUSH18": PUSH18, "PUSH16": PUSH16,
"PUSH19": PUSH19, "PUSH17": PUSH17,
"PUSH20": PUSH20, "PUSH18": PUSH18,
"PUSH21": PUSH21, "PUSH19": PUSH19,
"PUSH22": PUSH22, "PUSH20": PUSH20,
"PUSH23": PUSH23, "PUSH21": PUSH21,
"PUSH24": PUSH24, "PUSH22": PUSH22,
"PUSH25": PUSH25, "PUSH23": PUSH23,
"PUSH26": PUSH26, "PUSH24": PUSH24,
"PUSH27": PUSH27, "PUSH25": PUSH25,
"PUSH28": PUSH28, "PUSH26": PUSH26,
"PUSH29": PUSH29, "PUSH27": PUSH27,
"PUSH30": PUSH30, "PUSH28": PUSH28,
"PUSH31": PUSH31, "PUSH29": PUSH29,
"PUSH32": PUSH32, "PUSH30": PUSH30,
"DUP1": DUP1, "PUSH31": PUSH31,
"DUP2": DUP2, "PUSH32": PUSH32,
"DUP3": DUP3, "DUP1": DUP1,
"DUP4": DUP4, "DUP2": DUP2,
"DUP5": DUP5, "DUP3": DUP3,
"DUP6": DUP6, "DUP4": DUP4,
"DUP7": DUP7, "DUP5": DUP5,
"DUP8": DUP8, "DUP6": DUP6,
"DUP9": DUP9, "DUP7": DUP7,
"DUP10": DUP10, "DUP8": DUP8,
"DUP11": DUP11, "DUP9": DUP9,
"DUP12": DUP12, "DUP10": DUP10,
"DUP13": DUP13, "DUP11": DUP11,
"DUP14": DUP14, "DUP12": DUP12,
"DUP15": DUP15, "DUP13": DUP13,
"DUP16": DUP16, "DUP14": DUP14,
"SWAP1": SWAP1, "DUP15": DUP15,
"SWAP2": SWAP2, "DUP16": DUP16,
"SWAP3": SWAP3, "SWAP1": SWAP1,
"SWAP4": SWAP4, "SWAP2": SWAP2,
"SWAP5": SWAP5, "SWAP3": SWAP3,
"SWAP6": SWAP6, "SWAP4": SWAP4,
"SWAP7": SWAP7, "SWAP5": SWAP5,
"SWAP8": SWAP8, "SWAP6": SWAP6,
"SWAP9": SWAP9, "SWAP7": SWAP7,
"SWAP10": SWAP10, "SWAP8": SWAP8,
"SWAP11": SWAP11, "SWAP9": SWAP9,
"SWAP12": SWAP12, "SWAP10": SWAP10,
"SWAP13": SWAP13, "SWAP11": SWAP11,
"SWAP14": SWAP14, "SWAP12": SWAP12,
"SWAP15": SWAP15, "SWAP13": SWAP13,
"SWAP16": SWAP16, "SWAP14": SWAP14,
"LOG0": LOG0, "SWAP15": SWAP15,
"LOG1": LOG1, "SWAP16": SWAP16,
"LOG2": LOG2, "LOG0": LOG0,
"LOG3": LOG3, "LOG1": LOG1,
"LOG4": LOG4, "LOG2": LOG2,
"CREATE": CREATE, "LOG3": LOG3,
"CALL": CALL, "LOG4": LOG4,
"RETURN": RETURN, "CREATE": CREATE,
"CALLCODE": CALLCODE, "CALL": CALL,
"SELFDESTRUCT": SELFDESTRUCT, "RETURN": RETURN,
"CALLCODE": CALLCODE,
"SELFDESTRUCT": SELFDESTRUCT,
} }
func StringToOp(str string) OpCode { func StringToOp(str string) OpCode {

Write Preview
Loading…
Cancel
Save