VM与Opcodes

1）Virtual Machine

以太坊设计EVM的核心初衷：

V神：以太坊设计原理

EVM规范比其他许多虚拟机简单的多，因为其他虚拟机为复杂性付出的代价更小，也就是说它们更容易变得复杂；然而，在我们的方案中每额外增加一点复杂性，都会可能造成潜在的安全缺陷，比如造成共识失败，这就让我们的复杂性成本很高，因而不容易造成复杂；
EVM更加专业化，如支持32字节；
EVM没有复杂的外部依赖，复杂的外部依赖会导致我们安装失败，以太坊虚拟机运行在沙盒环境中，智能合约代码可在以太坊虚拟机内部运行并对外完全隔离，一定程度上提升了安全性；
完善的审查机制，可以具体到特殊的安全需求。

①概念理解

Ethereum Virtual Machine 是所有以太坊帐户和智能合约依存的环境。从一个区块到另一个区块，EVM作为执行层，依照ETH协议层，计算了新的有效状态的规则。区别于普通的计算机（键盘、网络、鼠标等输入和显示器、打印机、网络等输出），它的输入输出很少。

输入：
- 另一个VM传来的函数调用所携带的数据
- EOA调用合约账户所携带的交易数据
输出
- 运行过程中修改的区块链账户的存储（Account State Storage）
- 日志Log

此外，如前文所述，在链上任何给定的区块处，以太坊有且只有一个“规范”状态，EVM 作为一个堆栈机运行的执行层，具有“确定性”的特点。

当输入确定的时候，EVM的输出无论重复多少次运行也是唯一不变的输出。所以在以太坊虚拟机中寻找一个随机源是很困难的。

合约调用合约的底层：
以太坊中，执行代码的一台虚拟机可以启动另一台虚拟机来执行部分指令。这两台虚拟机都将在一个全节点上运行，形成多线程并行。这称之为“合约调用合约”。
如：合约A在执行计算时候需要调用 SafeMath 之类的安全数学计算库，而该库早已用合约的形式部署在以太坊网络上。则该合约A可以通过直接调用SafeMath库合约为自己服务。
1. 在调用时发送方将发出 CALL的虚拟机指令，并将环境变量例如 msg.sender （此时为EOA）等设置好。
2. 启动另一台虚拟机运行被调用方的代码，得出结果后通过 RETURN 虚拟机指令发还给调用方的内存区，完成调用过程。
../_images/Picture50.png
gas消耗：
../_images/Picture52.png

②源码分析

EVM的内存结构：

Stack

// core/vm/stack.go
// 实现了push、pop、dup、peek查看栈顶元素等方法
var stackPool = sync.Pool{
New: func() interface{} {
  // 使用切片，初始化堆栈空间深度为 256B * 16
  // 不同于以前直接分配1024深度的定长数组，优化内存分配
  return &Stack{data: make([]uint256.Int, 0, 16)}
  },
}


type Stack struct {
  // package uint256：type Int [4]uint64
  data []uint256.Int
}

func newstack() *Stack {
  return stackPool.Get().(*Stack)
}

Memory

// core/vm/memory.go
// 实现了Resize分配空间、Set设置值、Get取值等方法
type Memory struct {
  // 1B位宽，无线长度切片
  store       []byte
  lastGasCost uint64
}

// NewMemory returns a new memory model.
func NewMemory() *Memory {
  return &Memory{}
}

EVM的数据结构与初始化：

// core/vm/evm.go
type EVM struct {
  // 提供一些区块链信息辅助context
  Context BlockContext
  TxContext
  // StateDB状态存储的接口，EVM大部分工作都是围绕其展开
  StateDB StateDB
  // 记录当前调用栈深度
  depth int

  // 记录链配置, 因为以太坊经历过几次的提案分叉，所以做了一些兼容
  chainConfig *params.ChainConfig
  // 标识符，判断链规则（同上原因）
  chainRules params.Rules
  // VM的配置，用于初始化
  Config Config
  // EVM解释器对象，它是整个VM执行代码、处理交易的地方
  interpreter *EVMInterpreter
  // 用于终止代码执行
  abort int32
  // 用于存储当前调用的gas可用值
  callGasTemp uint64
}

func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config) *EVM {
    evm := &EVM{
      Context:     blockCtx,
      TxContext:   txCtx,
      StateDB:     statedb,
      Config:      config,
      chainConfig: chainConfig,
      chainRules:  chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil),
    }
    // 重点是创建解释器，解释器是执行字节码的关键
    evm.interpreter = NewEVMInterpreter(evm, config)
    return evm
}

EVM解释器Interpreter的创建初始化流程，主要是对Opcodes根据不同分叉版本的适配管理：

// core/vm/interpreter.go
func NewEVMInterpreter(evm *EVM, cfg Config) *EVMInterpreter {
  // 设置操作码对应的函数 
  // JumpTable即管理着EVM opcodes
  // 同样因为以太坊经历版本迭代之后，操作码有了一些变化，所以有多个情况
  if cfg.JumpTable == nil {
	  switch {
	  case evm.chainRules.IsMerge:
		  cfg.JumpTable = &mergeInstructionSet
	  case evm.chainRules.IsLondon:
		  cfg.JumpTable = &londonInstructionSet
	  case evm.chainRules.IsBerlin:
		  cfg.JumpTable = &berlinInstructionSet
	  case evm.chainRules.IsIstanbul:
		  cfg.JumpTable = &istanbulInstructionSet
	  case evm.chainRules.IsConstantinople:
		  cfg.JumpTable = &constantinopleInstructionSet
	  case evm.chainRules.IsByzantium:
		  cfg.JumpTable = &byzantiumInstructionSet
	  case evm.chainRules.IsEIP158:
		  cfg.JumpTable = &spuriousDragonInstructionSet
	  case evm.chainRules.IsEIP150:
		  cfg.JumpTable = &tangerineWhistleInstructionSet
	  case evm.chainRules.IsHomestead:
		  cfg.JumpTable = &homesteadInstructionSet
	  default:
		  cfg.JumpTable = &frontierInstructionSet
	  }
	  var extraEips []int
	  if len(cfg.ExtraEips) > 0 {
		  // Deep-copy jumptable to prevent modification of opcodes in other tables
		  cfg.JumpTable = copyJumpTable(cfg.JumpTable)
	  }
	  for _, eip := range cfg.ExtraEips {
		  if err := EnableEIP(eip, cfg.JumpTable); err != nil {
			  // Disable it, so caller can check if it's activated or not
			  log.Error("EIP activation failed", "eip", eip, "error", err)
		  } else {
			  extraEips = append(extraEips, eip)
		  }
	  }
	  cfg.ExtraEips = extraEips
  }

  return &EVMInterpreter{
	  evm: evm,
	  cfg: cfg,
  }
}

回到EVM的初始化入口。

Ethereum的虚拟机源码所有部分在core/vm下。EVM的调用的入口在core/state_transition.go目录中

// StateTransition 是当一笔交易应用于当前的世界状态时所产生的一个“变化change”
// 负责完成所有状态变化所对应的步骤，并最终生成新的 state trie root
func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
  ......
  // evm的入口
  // contractCreation = msg.To() == nil
  // 即如果交易的接受者为0地址，则判断为合约创建类型
  if contractCreation {
    // evm.Create()
    // 合约部署的 Code 同样通过transaction的data字段传入
    // data的构造包括：部署代码 (creation code)、合约代码 (runtime code)、(可选)辅助数据 (Auxdata)
    // demo：https://github.com/AmazingAng/WTF-		          Solidity/blob/main/Topics/Translation/DiveEVM2017/DiveEVM2017-Part5.md
	  ret, _, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
  } else {
    // 增加nonce值（防止重放攻击），为下一笔交易做准备
    st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
    // evm.Call()
    ret, st.gas, vmerr = st.evm.Call(sender, st.to(), st.data, st.gas, st.value)
  }
  ......
  return &ExecutionResult{
	  UsedGas:    st.gasUsed(),
	  Err:        vmerr,
	  ReturnData: ret,
  }, nil
}

合约部署：evm.Create() => evm.interpreter.Run()

// core/vm/evm.go
func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
  // 根据caller.address与caller.nonce生成合约地址
  contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
  // 从这上下两步可以看出，在合约创建初始化完成之前，合约地址已经生成了
  // 即对应solidity的constructor()阶段，code还没建立，但是可以取到address(this)的
  return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr, CREATE)
}

// EVM通过运行creation code部署并初始化合约，把runtime的合约代码返回并设置到合约地址
func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *big.Int, address common.Address, typ OpCode) ([]byte, common.Address, uint64, error) {
  // 检测当前evm执行的深度，默认不应该超过1024
  if evm.depth > int(params.CallCreateDepth) {
	  return nil, common.Address{}, gas, ErrDepth
  }
  // 检测是否调用方的金额大约value
  if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
	  return nil, common.Address{}, gas, ErrInsufficientBalance
  }
  // 首先获取调用者的nonce，然后nonce+1
  nonce := evm.StateDB.GetNonce(caller.Address())
  if nonce+1 < nonce {
	  return nil, common.Address{}, gas, ErrNonceUintOverflow
  }
  evm.StateDB.SetNonce(caller.Address(), nonce+1)
  // contract address加入到access list
  // 这个行为不需要也不该被回滚
  if evm.chainRules.IsBerlin {
	  evm.StateDB.AddAddressToAccessList(address)
  }
  // 确定指定的合约地址是唯一的
  contractHash := evm.StateDB.GetCodeHash(address)
  if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != emptyCodeHash) {
	  return nil, common.Address{}, 0, ErrContractAddressCollision
  }
  // 为合约地址在世界状态上层封装的stateDB中创建账户体系
  snapshot := evm.StateDB.Snapshot()
  evm.StateDB.CreateAccount(address)
  if evm.chainRules.IsEIP158 {
	  evm.StateDB.SetNonce(address, 1)
  }
  evm.Context.Transfer(evm.StateDB, caller.Address(), address, value)

  // 创建一个合约对象，并设置合约对象的参数，比如runtime code等
  // 参照core/vm/contract.go，contract代表以太坊stateDB里面的一个合约对象
  contract := NewContract(caller, AccountRef(address), value, gas)
  contract.SetCodeOptionalHash(&address, codeAndHash)

  if evm.Config.Debug {
	  if evm.depth == 0 {
		  evm.Config.Tracer.CaptureStart(evm, caller.Address(), address, true, codeAndHash.code, gas, value)
	  } else {
		  evm.Config.Tracer.CaptureEnter(typ, caller.Address(), address, codeAndHash.code, gas, value)
	  }
  }

  start := time.Now()
  // 核心：将合约对象传入解释器Run函数开始执行
  // 该函数为真正执行合约代码的地方
  // evm.Call()入口进入的时候最终也会调用此函数
  ret, err := evm.interpreter.Run(contract, nil, false)

  // 下面的流程主要是一些协议检查
  // Check whether the max code size has been exceeded, assign err if the case.
  if err == nil && evm.chainRules.IsEIP158 && len(ret) > params.MaxCodeSize {
	  err = ErrMaxCodeSizeExceeded
  }

  // Reject code starting with 0xEF if EIP-3541 is enabled.
  if err == nil && len(ret) >= 1 && ret[0] == 0xEF && evm.chainRules.IsLondon {
	  err = ErrInvalidCode
  }

  // 如果creationCode执行成功，则在stateDB中把返回的字节码（runtime code）
  // 保存到此合约账户(上面创建的)名下，这样之后调用合约代码才能加载成功
  // If the code could not
  // be stored due to not enough gas set an error and let it be handled
  // by the error checking condition below.
  if err == nil {
	  createDataGas := uint64(len(ret)) * params.CreateDataGas
	  if contract.UseGas(createDataGas) {
		  evm.StateDB.SetCode(address, ret)
	  } else {
		  err = ErrCodeStoreOutOfGas
	  }
  }

  // 如果发生任何错误，revert世界状态state至改变之前（通过snapshot）
  // 如果err不是ErrExecutionReverted错误，则消耗掉所有gas
  if err != nil && (evm.chainRules.IsHomestead || err != ErrCodeStoreOutOfGas) {
	  evm.StateDB.RevertToSnapshot(snapshot)
	  if err != ErrExecutionReverted {
		  contract.UseGas(contract.Gas)
	  }
  }

  if evm.Config.Debug {
	  if evm.depth == 0 {
		  evm.Config.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
	  } else {
		  evm.Config.Tracer.CaptureExit(ret, gas-contract.Gas, err)
	  }
  }
  return ret, address, contract.Gas, err
}

// core/vm/interpreter.go
// 运行代码loops并评估在给定input data情况下合约代码的执行情况，返回[]byte或error
// 除了ErrExecutionReverted（solidity：revert）错误会返还gas剩余给caller
// 其他解释器返回的错误都视为revert-and-consume-all-gas
func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (ret []byte, err error) {
  // 增加1堆栈深度，最大1024
  in.evm.depth++
  defer func() { in.evm.depth-- }()
  ......
  // 下面的变量满足了一个字节码执行的所有条件
  // 有操作码、内存、栈、PC程序计数器 
  // debug工具是用于跟踪执行的流程状态，运行时建议使用
  var (
	  op          OpCode        // current opcode
	  mem         = NewMemory() // bound memory
	  stack       = newstack()  // local stack
	  callContext = &ScopeContext{
		  Memory:   mem,
		  Stack:    stack,
		  Contract: contract,
	  }
	  // For optimisation reason we're using uint64 as the program counter.
	  // It's theoretically possible to go above 2^64. The YP defines the PC
	  // to be uint256. Practically much less so feasible.
	  pc   = uint64(0) // program counter
	  cost uint64
	  // copies used by tracer
	  pcCopy  uint64 // needed for the deferred EVMLogger
	  gasCopy uint64 // for EVMLogger to log gas remaining before execution
	  logged  bool   // deferred EVMLogger should ignore already logged steps
	  res     []byte // opcode执行函数返回的结果
	)
  // Don't move this deferred function, it's placed before the capturestate-deferred method,
  // so that it get's executed _after_: the capturestate needs the stacks before
  // they are returned to the pools
  defer func() {
	 returnStack(stack)
  }()
  contract.Input = input
  ......
  // 解释器执行opcodes的入口loop
  // 持续执行直到 STOP, RETURN 或 SELFDESTRUCT
  for {
	  if in.cfg.Debug {
		  // Capture pre-execution values for tracing.
		  logged, pcCopy, gasCopy = false, pc, contract.Gas
	  }
    
	  // 根据根据PC计数器获取操作码，根据操作码从JumpTable获取对应的操作函数
	  op = contract.GetOp(pc)
	  operation := in.cfg.JumpTable[op]
	  cost = operation.constantGas // For tracing
	  // 确保有足够的stack空间执行
	  if sLen := stack.len(); sLen < operation.minStack {
		  return nil, &ErrStackUnderflow{stackLen: sLen, required: operation.minStack}
	  } else if sLen > operation.maxStack {
		  return nil, &ErrStackOverflow{stackLen: sLen, limit: operation.maxStack}
	  }
	  if !contract.UseGas(cost) {
		  return nil, ErrOutOfGas
	  }
	  if operation.dynamicGas != nil {
       // 有些指令是需要额外的内存消耗，但并不是所有的指令
       // 在jump_table.go文件中可以看到他们具体每个操作码的对应的额外内存消耗计算
       // memorySize指向对应的计算消耗内存的函数，根据消耗的内存来计算消费的gas
	 var memorySize uint64
	 if operation.memorySize != nil {
		  memSize, overflow := operation.memorySize(stack)
		  if overflow {
			  return nil, ErrGasUintOverflow
		  }
		  // memory is expanded in words of 32 bytes. Gas
		  // is also calculated in words.
		  if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
			  return nil, ErrGasUintOverflow
		  }
	  }
	  // 计算此操作花费的gas数量，可用gas不足会抛出错误
	  var dynamicCost uint64
	  dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)
	  cost += dynamicCost // for tracing
	  if err != nil || !contract.UseGas(dynamicCost) {
		  return nil, ErrOutOfGas
	  }
	  // Do tracing before memory expansion
	  if in.cfg.Debug {
		  in.cfg.Tracer.CaptureState(pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
		  logged = true
	  }
	  if memorySize > 0 {
		  mem.Resize(memorySize)
	  }
  } else if in.cfg.Debug {
	  in.cfg.Tracer.CaptureState(pc, op, gasCopy, cost, callContext, in.returnData, in.evm.depth, err)
	  logged = true
  }
  // 开始执行此操作码对应的操作函数 
  // 操作码对应的操作函数都是在core/vm/opcodes.go中
  res, err = operation.execute(&pc, in, callContext)
  // 只有遇到err才会终止运行，其他的Opcodes都会返回nil
  // 注意即使是selfdestruct、revert或stop正常结束也会以err形式返回
  if err != nil {
	  break
  }
  // 更新PC计数器，继续loops
	pc++
  }
  ......
  return res, err
}

到了这里整个部署合约流程就完成了，回到evm.Create函数中可以看到了当run执行完成后会把runtime code最终设置到合约地址名下（opcodes会执行codeCopy指令后把runtime code从内input data加载到内存并返回），整个合约部署就算完成了。

合约调用：evm.Call() => evm.interpreter.Run()

调用智能合约和部署合约，在EVM看来就是交易的to地址不在nil而是一个具体的合约地址。同时input data不再是整个合约编译后的字节码了而是调用函数和对应的实参组合。这里就涉及到另一个东西那就是abi的概念（可查看编码方式章节）。

// core/vm/evm.go
func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
	// stack深度检查
	if evm.depth > int(params.CallCreateDepth) {
		return nil, gas, ErrDepth
	}
	// 账户余额检查
	if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
		return nil, gas, ErrInsufficientBalance
	}
	snapshot := evm.StateDB.Snapshot()
	p, isPrecompile := evm.precompile(addr)

  // 判断这个合约地址是否存在，如果不存在是否是内置(预编译)合约 
  if !evm.StateDB.Exist(addr) {
	  if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
		  // Calling a non existing account, don't do anything, but ping the tracer
		  if evm.Config.Debug {
			  if evm.depth == 0 {
				  evm.Config.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
				  evm.Config.Tracer.CaptureEnd(ret, 0, 0, nil)
			  } else {
				  evm.Config.Tracer.CaptureEnter(CALL, caller.Address(), addr, input, gas, value)
				  evm.Config.Tracer.CaptureExit(ret, 0, nil)
			  }
		  }
		  return nil, gas, nil
	  }
	  evm.StateDB.CreateAccount(addr)
  }
  // 执行 ETH Token转账
  evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)
  ......
  if isPrecompile {
	  ret, gas, err = RunPrecompiledContract(p, input, gas)
  } else {
       // Initialise a new contract and set the code that is to be used by the EVM.
	 // The contract is a scoped environment for this execution context only.
	 code := evm.StateDB.GetCode(addr)
	 if len(code) == 0 {
		  ret, err = nil, nil // gas is unchanged
	 } else {
		  addrCopy := addr
      // 不管是部署合约还是调用合约都要先创建合约对象用例，把存储中合约code加载出来挂到合约对象下
      // 这里可以看到，CALL指令执行时会创建新的Contract对象，并以内存中的调用参数作为其Input
      // (区别于delegatecall、callcode的实现，会将object contract也配置为caller contract)
      // 解释器会为新合约的执行创建新的Stack和Memory，从而不会破环原合约的执行环境
		 contract := NewContract(caller, AccountRef(addrCopy), value, gas)
		 contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)
      // 依然是调用解释器的run函数来执行代码，不同之处在于这次的input不在是nil了，而是交易的input内容
  	// 正如前面提到，input会在交易的data中，CALLDATALOAD这个指令会用于加载input的内容
		 ret, err = evm.interpreter.Run(contract, input, false)
		 gas = contract.Gas
	  }
  }
  // 如果发生任何错误，revert世界状态state至改变之前（通过snapshot）
  // 如果不是ErrExecutionReverted错误，则消耗掉所有gas
  if err != nil {
	  evm.StateDB.RevertToSnapshot(snapshot)
	  if err != ErrExecutionReverted {
		  gas = 0
	  }
  }
  return ret, gas, err
}

2）字节码Opcodes指令

①源码分析

EVM的操作码和其他汇编语言的指令码类似。只是一般的CPU是基于寄存器的哈弗架构或者冯诺依曼架构。 EVM是基于栈式结构，大端序(数据的低位字节存放在内存的高位地址，高位字节存放在低位地)的256bit的虚拟机。每一个字节码是一个字节。

jump_table 是一个 [256]*operation 的数据结构。每个下标对应了一种指令，使用operation来存储了指令对应的处理逻辑、gas消耗、堆栈验证方法、memory使用的大小等功能，数据结构operation存储了一条指令的所需要的属性和方法。

// core/vm/jump_table.go

// JumpTable contains the EVM opcodes supported at a given fork.
type JumpTable [256]*operation

// operation
type operation struct {
  // 执行函数
  execute     executionFunc
  // operation所消耗gas固定值
  constantGas uint64
  // 预留gas实际动态消耗计算函数
  dynamicGas  gasFunc
  // 本次operation所需最小stack空间
  minStack int
  // 能为本次operation分配的最大stack空间
  maxStack int

  // 计算本次operation所需的内存大小的函数
  memorySize memorySizeFunc
}

// 不同版本指令集，针对不同的以太坊版本
var (
  frontierInstructionSet         = newFrontierInstructionSet()
  homesteadInstructionSet        = newHomesteadInstructionSet()
  tangerineWhistleInstructionSet = newTangerineWhistleInstructionSet()
  spuriousDragonInstructionSet   = newSpuriousDragonInstructionSet()
  byzantiumInstructionSet        = newByzantiumInstructionSet()
  constantinopleInstructionSet   = newConstantinopleInstructionSet()
  istanbulInstructionSet         = newIstanbulInstructionSet()
  berlinInstructionSet           = newBerlinInstructionSet()
  londonInstructionSet           = newLondonInstructionSet()
  mergeInstructionSet            = newMergeInstructionSet()
)

②Opcodes学习（结合Solidity）

Opcodes的定义可见：core/vm/opcodes.go

Opcodes指令集：opcode的长度为1个字节也就是最多支持256种opcode，现在EVM已使用140种(2022.12)

知识点实例一：内存数据长度（length）

bytes memory data = 0x1234;
uint size = data.length;
assembly{
	pop(call(gas(), addr, 0, add(data, 0x20), size, 0,0))
}
对于动态数组如bytes/string类型，solidity编译时，data指针指向的是内存数据块的长度，而紧接着的data+0x20指针指向的是内存数据库开始位置处，故这里作了add(data, 0x20)处理

知识点实例二：内存布局(layout in memory)与空闲指针(Free Memory Pointer)

Solidity的内存布局保留了4个32字节的插槽:
0x00 - 0x3f (64 bytes): scratch space：哈希计算方法的预留空间，以便在inline assembly可以使用方法
0x40 - 0x5f (32 bytes): free memory pointer
0x60 - 0x7f (32 bytes): zero slot：被用作动态内存数组的初始值，永远不能被写入
可以看到，0x40是solidity为freeMemoryPointer预留的位置。值0x80只是在4个保留的32字节的插槽之后第一个可写的位置。

Free Memory Pointer是一个指向自由内存开始位置的指针。它确保智能合约知道已写入和未写入的内存位置。这可以防止合约覆盖一些已经分配给另一个变量的内存。当一个变量被写入内存时，合约将首先参考Free Memory Pointer，以确定数据应该被存储在哪里。然后，它更新Free Memory Pointer，指出有多少数据将被写入新的位置。这两个值的简单相加将产生新的自由内存的起始位置。

freeMemoryPointer + dataSizeBytes(数据大小) = newFreeMemoryPointer

Solidity 通过free Memory Pointer管理内存，如果要分配内存，需从此指针指向的位置开始使用内存并更新内存

1、初始化：

60 80                       =   PUSH1 0x80
60 40                       =   PUSH1 0x40
52                          =   MSTORE

实际上说明了free Memory Pointer在内存中位于memory中的0x40(十进制：64)位置，其值为0x80(十进制128)。

2、使用

读取当前free pointer memory指向的位置

// 伪代码
array_memory = memory[0x40]
// Yul
mload(0x40)

本次使用code大小过后，计算并更新free pointer memory下一个要指向的值

// 要考虑code长度额外的32字节，并最终将其向上取整32字节。
// 数学公式： trunc((code_size + 32 + 32-1)/32) * 32
// 伪代码
array_size = (code_size + 0x20 + 0x1f) & ~0x1f
// Yul
mstore(0x40, add(code, and(add(add(size, 0x20), 0x1f), not(0x1f))))

知识点实例三：内存拓展（memory expansion）

(32字节的数据为右对齐)
当合约写内存时，你必须为所写的字节数付费。如果写到一个以前没有被写过的内存区域，那么第一次使用该区域会有一个额外的内存扩展费用。所以，当写到以前未使用的内存空间时，EVM会直接讲内存以32字节（256位）的增量进行扩展。
当再写入一个单字节数据0x22，即使MSTORE8写到内存中后，结果也是如图

知识点实例四：负整数（Negative integers）与溢出管理

负整数通常使用二进制补码的方式表示。 int8 编码类型的值 -1 将全部为 1 1111 1111。
ABI 用 1 填充负整数，因此 -1 将被填充为：
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
注意：小的负数大部分是 1，这会花费很多 gas
EVM在处理溢出问题时直接对溢出位进行舍弃，对结果进行取模（默认modulo为2^256 ）

知识点实例五：Opcodes执行环境

当 EVM 执行智能合约时，将为其创建context执行上下文环境。context由几个内存区域组成，每个区域都有自己的用途，如下：

The Code：
account code的存储区域，它是持久性的，是帐户属性的一部分(对应accountState的字段)。在智能合约执行期间，EVM 将读取、解释和执行这些字节码。code是只读的，但可以使用指令 CODESIZE 和 CODECOPY 读取该区域。其他合约也可以用 EXTCODESIZE 和 EXTCODECOPY 读取。EOA该区域为空。
The Stack：
一个包含32字节*1024元素的列表。堆栈用于放置指令所需的参数及其结果值。当一个新的值被放到堆栈上时，它被放到顶部，并且指令只使用顶部的值（前文也多次详述）。
The Memory：
一个只在智能合约执行期间存在的字节数组，以32字节为单位扩展，以通过offset (字节偏移量) 访问。每个字节初始化为0，但不管是否使用，大小将按访问的最大值计数。通常使用 MLOAD 和 MSTORE 指令来读写，但也被其他指令如 CREATE 或 EXTCODECOPY使用。
The Storage：
对应Solidity动态类型的存储规则
map：存储于第position位置slot的map，其value的存储位置默认为slot[keccak256(bytes32(key) + bytes32(position))]，因为每个slot只有 32 个字节，如果value超过32字节(比如struct)，超出的部分存储于上述keccak计算结果+1(以32字节为单位递增)的位置
slice：原slot[position]位置存储slice.length，下标0的元素存储于slot[keccak256(bytes32(position))]，下标index存储于slot[keccak256(bytes32(position)) + 1]
智能合约的持久化存储区域，对应account Storage Trie中每个账户的storage空间。它是32字节到32字节值的映射，保留写入的每个值直到将其设置为0或SELFDESTRUCT。读取未设置过的键也会返回0。通过 SLOAD 和 SSTORE 指令读写。此外，storage在EVM中存储时存在32字节紧打包优化
The Calldata：
存储的是跟随transaction一起发送的数据。在创建合约时，它是存储creation code (构造函数代码)。同样该区域是不可改变的，可以通过使用 CALLDATASIZE 的 CALLDATALOAD 和 CALLDATaCOPY 指令来读取。
The Return Data：
存储智能合约在调用后返回的值。将存储通过 RETURN 和 REVERT 指令调用外部合约后，外部合约的返回值。也可以在本合约通过使用 RETURNDATASIZE 和 RETURNDATACOPY 指令读取。

知识点实例六：预编译合约(Precompiled Contract)

core/vm/contracts.go

EVM 通过预编译合约提供了一组更高级的功能，并且可以避免常用的复杂计算所带来的代价。预编译合约是一种特殊的合约，有固定的地址和固定的gas消耗(合约自身内部代码执行的消耗，并不考虑 CALL 行为本身所带来的gas消耗)。其在opcodes中的使用方式、调用方式如普通合约一样，通过如 CALL这样的指令。

另外在输入参数方面，对于所有预编译合约，如果输入比预期的要短，则默认用0填充。如果输入比预期的长，则忽略末尾多余的字节。另外在 Berlin分叉 之后，所有预编译的合约地址总是被认为是 'warm' (access set)。

注：Solidity中的keccak256是EVM内部实现的SHA3系列，未通过预编译合约形式
其它两个哈希算法虽然没怎么用到，但源于以太坊一开始是基于比特币设计的，黄皮书中有定义，故而保留（注：SHA256属于SHA2-family）
哈希算法的三个特性：
唯一性：输入任意内容可输出定长的内容，相同的输入一定会产出相同的输出，抗碰撞；
雪崩效应：即使一个极小的改变都会产生几乎完全不同的哈希值；
单向性：无法反向推导出pre-image(被哈希的内容的)。

Address

Name

Description

Input（默认从左向右为：栈顶 => 向下）

Output

Gas

0x01

ecRecover

通过signed transaction hash及签名v,r,s，进行椭圆曲线数字签名算法(ECDSA)公钥恢复signer address，gas不足返回值为空

txhash,v,r,s

address

3000

0x02

SHA2-256

SHA256哈希算法(Bitcoin使用，属于SHA2系列)，产生256位输出，gas不足返回值为空，对应Solidity中sha256

data

hash

60+

0x03

RIPEMD-160

RIPEMD-160哈希算法 (Bitcoin使用)，产生160位输出，gas不足返回值为空，对应Solidity中ripemd160

data

hash

600+

0x04

identity

返回输入的data，通常用于复制内存块，gas不足返回值为空

data

15+

0x05

modexp

计算 $B^{E}\ mod \ M$ (B/E/Msize为对应值所占字节大小)的任意精度指数，E为0固定返回1，M为1固定返回0，gas不足返回值为空

Bsize,Esize,Msize,B,E,M

value

200+

0x06

ecAdd

椭圆曲线'alt_bn128'上两点 (x,y) 的相加(ADD)，无穷远点的 x 和 y 均为0，入参无效或gas不足返回值为空

x1,y1,x2,y2

x,y

150+

0x07

ecMul

BN128椭圆曲线上点与标量相乘(MUL)，s为标量scalar，无穷远点的 x 和 y 均为0

x1,y1,s

x,y

6000+

0x08

ecPairing

BN128椭圆曲线的双线性函数配对操作，将用于zk-SNARK验证，入参无效或gas不足返回值为空

x1,y1,x2,y2...xk,yk

success

45000+

0x09

blake2f

实现blake2哈希函数，并在 BLAKE2 哈希算法中使用压缩函数 F ，使用的次数rounds(大端对齐)

rounds,h,m,t,f

h

定义类知识点：

Empty Account：如果帐户的balance为0，nonce 为0且没有code，则定于该帐户为空账户
Intrinsic Gas：每笔transaction的 “基本花销” 为21000 gas。在该基础上，部署一个contract需要花费 “基本花销” 32000 gas。之后，对于calldata，每0字节花费4gas，非0则花费16gas( Istanbul分叉之前是64gas)。这些费用需在执行任何opcodes或transfer之前被支付。
Gas Refund：部分opcodes可以触发gas refund，从而降低交易的gas成本。然而，gas refund是在一笔transaction最后执行，这意味着transaction仍然需要足够的gas来运行完成(就好像不存在gas refund一样)。
此外，可以退还的gas数量也是有限的，不能超过整个transaction成本的一半(London分叉前)，现在不能超过五分之一。并且从London分叉开始，只有 SSTORE 可能会触发gas refund，在此之前，SELFDESTRCT 也可以。
Access Set：Berlin分叉后出现的概念，存在于access set的地址标识为'warm'，不存在则标识为'cold'，一些opcodes的动态开销与其有关。access set与每笔transaction绑定(而不是调用context)。access set中存在两个变量如下：
```
// eth/tracers/loggers/access_list_tracer.go
type AccessListTracer struct {
	excl map[common.Address]struct{} // Set of account to exclude from the list
	list accessList                  // Set of accounts and storage slots touched
}
```
- touched_addresses：存储一组当前transaction中被访问过的contract address。它被初始化为sender、receiver (CA/EOA)和预编译合约。当操作码访问access set中不存在的地址时，它会将其添加到集合中。相关的操作码为 EXTCODESIZE、 EXTCODECOPY、 EXTCODEHASH、 BALANCE、 CALL、 CALLCODE、 DELEGATECALL、 STATICCCALL、 CREATE、 CREATE2和 SELFDESTRUCT。
- touched_storage_slots：存储一组已访问的contract address及其slot key。它被初始化为空。当操作码访问access set中不存在的slot时，它会将其添加到其中。相关的操作码为 SLOAD 和 SSTORE
注：如果发生context revert，access set也会恢复到它们在该context之前的状态

Opcode

Mnemonic

Description

Input（默认从左向右为：栈顶 => 向下）

Output

Gas

0x00

STOP

结束合约执行并退出

0x01

ADD

(u)int256，取模$2^{256}$

a,b

(a+b)

0x02

MUL

(u)int256，取模$2^{256}$

a,b

(a*b)

0x03

SUB

(u)int256，取模$2^{256}$

a,b

(a-b)

0x04

DIV

整除，uint256除法

a,b

(a/b)

0x05

SDIV

整除，int256除法

a,b

(a/b)

0x06

MOD

uint256，取模$2^{256}$

a,b

(a%b)

0x07

SMOD

int256，取模$2^{256}$

a,b

(a%b)

0x08

ADDMOD

(u)int256加法，取模N

a,b,N

(a+b)%N

0x09

MULMOD

(u)int256乘法，取模N

a,b,N

(a*b)%N

0x0a

EXP

uint256指数结果，取模$2^{256}$

a,exp

a**exp

10+

0x0b

SIGNEXTEND

把x解释为b+1（0 <= b <= 31）字节有符号整数(二进制补码形式)，然后把x的符号位复制填充，至扩展输出为32字节

b,x

y

0x0c - 0x0f

Unused

0x10

uint256小于比较，满足返回1，不满足返回0

a,b

a<b

0x11

uint256大于比较，满足返回1，不满足返回0

a,b

a>b

0x12

SLT

int256(补码)小于比较，满足返回1，不满足返回0

a,b

a<b

0x13

SGT

int256(补码)小于比较，满足返回1，不满足返回0

a,b

a>b

0x14

(u)int256相等比较，满足返回1，不满足返回0

a,b

a==b

0x15

ISZERO

(u)int256零比较，满足返回1，不满足返回0

a

a==0

0x16

AND

256位的位与计算

a,b

a&b

0x17

256位的位或计算

a,b

0x18

XOR

256位的异或计算

a,b

a^b

0x19

NOT

256位的位取反计算

a

~a

0x1a

BYTE

返回(u)int256 x从最高字节开始的第i字节：y=(x>>(248-i*8)) &0xFF

i,x

y

0x1b

SHL

256位左移位，新位置0：EIP145

shift,value

value<<shift

0x1c

SHR

256位右移，新位置0：EIP145

shift,value

value>>shift

0x1d

SAR

考虑符号位的256右移位，新位符号位保持，其他位置0：EIP145

shift,value

value>>shift

0x20

SHA3

从memory偏移offset的位置加载size的值作为入参，计算keccak256哈希

offset,size

hash

30+

0x21 - 0x2f

Unused

0x30

ADDRESS

获取当前执行合约的地址

address(this)

0x31

BALANCE

获取指定地址的余额，单位wei，地址不存在返回0，动态gas(依据access sets)

address

address.balance

100+

0x32

ORIGIN

获取交易发起方EOA的地址

tx.origin

0x33

CALLER

回去消息调用方地址

msg.sender

0x34

CALLVALUE

获取以wei为单位的消息调用携带金额

msg.value

0x35

CALLDATALOAD

读取calldata(16进制表示的字节{偶数个})偏移i字节，注意：若calldata不足32字节会右侧补0

i

calldata[i:]

0x36

CALLDATASIZE

返回以字节为单位的消息数据j长度

size(calldata)

0x37

CALLDATACOPY

拷贝calldata偏移offset字节的数据至偏移destOffset的memory位置

destOffset,offset,size

0x38

CODESIZE

返回以字节为单位的，当前环境执行合约 (context中的code区域，实际即总字节码长度) 的代码(字节码)长度

size(address(this).code)

0x39

CODECOPY

拷贝address(this).code偏移offset字节的size大小的数据至偏移destOffset的memory位置

destOffset,offset,size

0x3a

GASPRICE

返回当前执行交易的单位gas价格，以wei为单位

tx.gasprice

0x3b

EXTCODESIZE

获取指定address的code字节码长度，以字节为单位，动态gas(依据access sets)

address

size(address.code)

100+

0x3c

EXTCODECOPY

拷贝指定address字节码偏移offset字节的size大小的数据至偏移destOffset的memory位置，动态gas(依据access sets)

address,destOffset,offset,size

100+

0x3d

RETURNDATASIZE

返回最后一个外部调用(如call、delegatecall...)返回的数据(return data有专门的return value区域，并非如普通返回值在stack中)的长度，以字节为单位。EIP 211

size(return data)

0x3e

RETURNDATACOPY

拷贝return data偏移offset字节的size大小的数据至偏移destOffset的memory位置。EIP 211

destOffset,offset,size

0x3f

EXTCODEHASH

返回指定address的code字节码的哈希，EIP 1052，动态gas(依据access sets)

address

hash(address(this).code)

100+

0x40

BLOCKHASH

获得指定blockNumber的哈希，仅适用于最近的256个区块且不包括当前区块

blockNumber

blockhash(blockNumber)

0x41

COINBASE

获取当前区块的矿工的地址

block.coinbase

0x42

TIMESTAMP

获取当前区块的UNIX时间戳，以秒为单位

block.timestamp

0x43

NUMBER

获取当前区块号

block.number

0x44

DIFFICULTY

获取当前区块难度

block.difficulty

0x45

GASLIMIT

获取当前区块GAS上限

block.gaslimit

0x46

CHAINID

获取当前区块的chainId，EIP 1344

block.chainid

0x47

SELFBALANCE

获取当前环境下，执行账户address的余额，Wei为单位 (对比BALANCE消耗更少的GAS)

address(this).balance

0x48

BASEFEE

获取当前区块的基础gas fee，Wei为单位，EIP 3198

block.basefee

0x49 - 0x4f

Unused

0x50

POP

弹出栈顶(u)int256值并丢弃

0x51

MLOAD

从memory偏移offset个字节的位置读取一个(u)int256到stack(值前面的0会舍弃)，动态gas(会触发memory expansion，根据其判断)

offset

value

0x52

MSTORE

向memory偏移offset个字节的位置，写入一个(u)int256，动态gas(依据memory expansion)

offset,value

0x53

MSTORE8

向memory偏移offset个字节的位置，写入一个(u)int8，动态gas(依据memory expansion)

offset,value

0x54

SLOAD

从storage的slot[key]读取一个(u)int256，如果该slot未被写入过则返回0，动态gas(依据access sets)

key

value

100+

0x55

SSTORE

向storage的slot[key]写入一个(u)int256，动态gas比较复杂，涉及gas refund等，首次写入消耗20000gas

key,value

100+

0x56

JUMP

无条件跳转，即改变执行环境code中PC 至偏移counter字节的位置，跳转地点必须对应为JUMPDEST指令

counter

0x57

JUMPI

条件跳转，如果b不等于0，改变执行环境code中PC至偏移counter字节的位置。否则PC按正常顺序线性增加，跳转地点必须对应为JUMPDEST指令

counter,b

0x58

一个指向字节码中下一个操作码的指针，由 EVM 执行。它是一个非负整数，实际是字节码中的字节偏移数。获取的是 “执行当前指令增量之前” (即不包含此次PC指令)的PC值。

counter

0x59

MSIZE

获取当前合约执行环境下的current memory (因为存在memory expansion) 大小，以字节为单位

size

0x5a

GAS

返回当前剩余的GAS

gasleft()

0x5b

JUMPDEST

为跳转指令(JUMP/JUMPI)标记一个有效的目的地

0x5c - 0x5f

Unused

0x60

PUSH1

将1字节的值压入栈顶，该系列指令后面紧跟待压入的数据如：PUSH1 FF

value

0x61

PUSH2

将2字节的值压入栈顶

value

0x62

PUSH3

将3字节的值压入栈顶

value

0x63

PUSH4

将4字节的值压入栈顶

value

0x64

PUSH5

将5字节的值压入栈顶

value

0x65

PUSH6

将6字节的值压入栈顶

value

0x66

PUSH7

将7字节的值压入栈顶

value

0x67

PUSH8

将8字节的值压入栈顶

value

0x68

PUSH9

将9字节的值压入栈顶

value

0x69

PUSH10

将10字节的值压入栈顶

value

0x6a

PUSH11

将11字节的值压入栈顶

value

0x6b

PUSH12

将12字节的值压入栈顶

value

0x6c

PUSH13

将13字节的值压入栈顶

value

0x6d

PUSH14

将14字节的值压入栈顶

value

0x6e

PUSH15

将15字节的值压入栈顶

value

0x6f

PUSH16

将16字节的值压入栈顶

value

0x70

PUSH17

将17字节的值压入栈顶

value

0x71

PUSH18

将18字节的值压入栈顶

value

0x72

PUSH19

将19字节的值压入栈顶

value

0x73

PUSH20

将20字节的值压入栈顶

value

0x74

PUSH21

将21字节的值压入栈顶

value

0x75

PUSH22

将22字节的值压入栈顶

value

0x76

PUSH23

将23字节的值压入栈顶

value

0x77

PUSH24

将24字节的值压入栈顶

value

0x78

PUSH25

将25字节的值压入栈顶

value

0x79

PUSH26

将25字节的值压入栈顶

value

0x7a

PUSH27

将27字节的值压入栈顶

value

0x7b

PUSH28

将28字节的值压入栈顶

value

0x7c

PUSH29

将29字节的值压入栈顶

value

0x7d

PUSH30

将30字节的值压入栈顶

value

0x7e

PUSH31

将31字节的值压入栈顶

value

0x7f

PUSH32

(full word) 将32字节的值压入栈顶

value

0x80

DUP1

取stack上的第1个值(1st 栈顶)并返回至栈顶

value

value,value

0x81

DUP2

忽略stack上的前1个值，复制stack上的第2个值，并粘贴至栈顶

a,b

b,a,b

0x82

DUP3

忽略stack上的前2个值，复制stack上的第3个值，并粘贴至栈顶

a,b,c

c,a,b,c

0x83

DUP4

忽略stack上的前3个值，复制stack上的第4个值，并粘贴至栈顶

a,b,c,d

d,a,b,c,d

0x84

DUP5

忽略stack上的前4 (=n-1)个值，复制stack上的第5 (=n)个值，并粘贴至栈顶

stack[0],...stack[n-1], stack[n]