roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

core/vm: implement RETURNDATA metropolis opcodes

Browse Source
This commit is contained in:
Jeffrey Wilcke 2017-08-16 13:07:33 +03:00 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 Stats Download Patch File Download Diff File Expand all files Collapse all files

26
core/vm/gas_table.go
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
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
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
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
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
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 {