Evm7种重要指令的实现原理
Evm7种重要指令的实现原理：
Evm的所有指令定义都在core/vm/jump_table.go里实现的，而每个指令对应的操作函数都是在core/vm/instructions.go里实现的。
如果一个节点并发调用智能合约，那么对memory的操作是否有线程安全问题。不会，因为每执行一个交易，都会创建一个新的evm对象。只有最终写入statedb的数据会有线程安全问题。
基本原理：一个指令占一个字节，也就是8为，16进制从0x01到0xff，10进制从1到255。最多255个指令，如果加上0的话，就256个指令。evm执行指令的主要载体是栈。
栈里的dup函数实现把栈上的某个值存入intpool中。
1.Mload和Mstore指令（ 这里的m是memory的意思）
mload：花费32gas*数据大小，用途：取出栈顶的元素作为key，从memory中取出该key对应的value，存入initpoll中最新元素，并且把该值压入栈中。
Mstore：取出栈上的最新的两个数据，一个作为key，一个作为value，写入memory，并且存入initpoll中。initpoll也是一个栈的结构
func opMload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
offset := stack.pop()
val := interpreter.intPool.get().SetBytes(memory.Get(offset.Int64(), 32))
stack.push(val)
interpreter.intPool.put(offset)
return nil, nil
}
func opMstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
// pop value of the stack
mStart, val := stack.pop(), stack.pop()
memory.Set32(mStart.Uint64(), val)
interpreter.intPool.put(mStart, val)
return nil, nil
}
// intPool is a pool of big integers that
// can be reused for all big.Int operations.
type intPool struct {
pool *Stack
}
2.sload和sstore指令（ 这里的s是statedb的意思）
sload：从statedb中取出合约地址下面的某个key对应的value值，存入栈的最新元素里。sload固定是200gas
Sstore：从栈中取中两个值作为key和value，然后在statedb中存入刚才取出的key和value，并且在initpool中放入该value。
func opSload(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
loc := stack.peek()
val := interpreter.evm.StateDB.GetState(contract.Address(), common.BigToHash(loc))
loc.SetBytes(val.Bytes())
return nil, nil
}
func opSstore(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
loc := common.BigToHash(stack.pop())
val := stack.pop()
interpreter.evm.StateDB.SetState(contract.Address(), loc, common.BigToHash(val))
interpreter.intPool.put(val)
return nil, nil
}
3.push1，push2… push32指令集，对应调用的是makePush(1,1)…makePush(32,32) 。gas费用都是3
实现的功能是：从字节指令代码数据中取出从pc计数器到x个指令出来，压入栈中。x为1到32。
// make push instruction function
func makePush(size uint64, pushByteSize int) executionFunc {
return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
codeLen := len(contract.Code)
startMin := codeLen
if int(*pc+1) < startMin {
startMin = int(*pc + 1)
}
endMin := codeLen
if startMin+pushByteSize < endMin {
endMin = startMin + pushByteSize
}
integer := interpreter.intPool.get()
stack.push(integer.SetBytes(common.RightPadBytes(contract.Code[startMin:endMin], pushByteSize)))
*pc += size
return nil, nil
}
}
4.dup1，dup2… dup16指令，对应调用的是makeDup(1)…makeDup(16) 。gas费用都是3
dump是转存的意思，主要实现的是把栈中的某个元素压入栈顶
具体实现的功能是：从栈顶开始算起，把栈上第x个元素存入intpool的栈顶，并且把该元素也存入栈的栈顶。
// make dup instruction function
func makeDup(size int64) executionFunc {
return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
stack.dup(interpreter.intPool, int(size))
return nil, nil
}
}
func (st *Stack) dup(pool *intPool, n int) {
st.push(pool.get().Set(st.data[st.len()-n]))
}
5.swap1，swap2… swap16指令，对应调用的是makeSwap(1)…makeSwap(16) 。gas费用都是3
实现的功能是：把栈上的第x个元素和栈顶元素进行交换
// 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, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
stack.swap(int(size))
return nil, nil
}
}
func (st *Stack) swap(n int) {
st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n]
}
6.log1，log2… log4指令，对应调用的是makeLog(1)…makeLog(4) 。gas费用是 8gas* 字节大小
实现的功能是：根据栈的前两个元素作为key和size，从内存里取出相应的数据，存入statedb的journal（日志）里。1，2，3，4代表的是日志的主题，一次最多可以存入4个主题。
如果有多个主题，取数据的时候从data里切分出不同主题的数据。
// make log instruction function
func makeLog(size int) executionFunc {
return func(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
topics := make([]common.Hash, size)
mStart, mSize := stack.pop(), stack.pop()
for i := 0; i < size; i++ {
topics[i] = common.BigToHash(stack.pop())
}
d := memory.Get(mStart.Int64(), mSize.Int64())
interpreter.evm.StateDB.AddLog(&types.Log{
Address: 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.BlockNumber.Uint64(),
})
interpreter.intPool.put(mStart, mSize)
return nil, nil
}
}
func (self *StateDB) AddLog(log *types.Log) {
self.journal.append(addLogChange{txhash: self.thash})
log.TxHash = self.thash
log.BlockHash = self.bhash
log.TxIndex = uint(self.txIndex)
log.Index = self.logSize
self.logs[self.thash] = append(self.logs[self.thash], log)
self.logSize++
}
7.create，call，callcode，return
（1） Create指令实现的是创建合约，将会调用
res, addr, returnGas, suberr := interpreter.evm.Create(contract, input, gas, value)（2）call指令实现的是调用合约，将会调用
ret, returnGas, err := interpreter.evm.Call(contract, toAddr, args, gas, value)
（3）callcode指令实现的是一个合约调用其他合约，最终将会调用callcode方法，和call方法最大不同的是执行合约的上下文是调用者，而不是将要执行的合约。
ret, returnGas, err := interpreter.evm.CallCode(contract, toAddr, args, gas, value)callcode一般发生在定义了多个合约，其中一个合约调用了其他合约的方法。
（4）return指令实现的是：从内存中，以栈顶的前两个元素作为偏移量和size，取出相应的数据放入intpool中，并返回数据
func opReturn(pc *uint64, interpreter *EVMInterpreter, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
offset, size := stack.pop(), stack.pop()
ret := memory.GetPtr(offset.Int64(), size.Int64())
interpreter.intPool.put(offset, size)
return ret, nil
}