以太坊 EVM原理与实现

以太坊底层通过EVM模块支持合约的执行与调用，调用时根据合约地址获取到代码，生成环境后载入到EVM中运行。通常智能合约的开发流程是用solidlity编写逻辑代码，再通过编译器编译元数据，最后再发布到以太坊上。

  1. 代码结构
  2. .
  3. ├── analysis.go            //跳转目标判定
  4. ├── common.go
  5. ├── contract.go            //合约数据结构
  6. ├── contracts.go           //预编译好的合约
  7. ├── errors.go
  8. ├── evm.go                 //执行器 对外提供一些外部接口
  9. ├── gas.go                 //call gas花费计算 一级指令耗费gas级别
  10. ├── gas_table.go           //指令耗费计算函数表
  11. ├── gen_structlog.go
  12. ├── instructions.go        //指令操作
  13. ├── interface.go
  14. ├── interpreter.go         //解释器 调用核心
  15. ├── intpool.go             //int值池
  16. ├── int_pool_verifier_empty.go
  17. ├── int_pool_verifier.go
  18. ├── jump_table.go           //指令和指令操作（操作，花费，验证）对应表
  19. ├── logger.go               //状态日志
  20. ├── memory.go               //EVM 内存
  21. ├── memory_table.go         //EVM 内存操作表 主要衡量操作所需内存大小
  22. ├── noop.go
  23. ├── opcodes.go              //Op指令 以及一些对应关系
  24. ├── runtime
  25. │   ├── env.go              //执行环境
  26. │   ├── fuzz.go
  27. │   └── runtime.go          //运行接口 测试使用
  28. ├── stack.go                //栈
  29. └── stack_table.go          //栈验证

指令

OpCode

文件opcodes.go中定义了所有的OpCode，该值是一个byte，合约编译出来的bytecode中，一个OpCode就是上面的一位。opcodes按功能分为9组（运算相关，块操作，加密相关等）。

  1.     //算数相关
  2.     const (
  3.         // 0x0 range - arithmetic ops
  4.         STOP OpCode = iota
  5.         ADD
  6.         MUL
  7.         SUB
  8.         DIV
  9.         SDIV
  10.         MOD
  11.         SMOD
  12.         ADDMOD
  13.         MULMOD
  14.         EXP
  15.         SIGNEXTEND
  16.     )

Instruction

文件jump.table.go定义了四种指令集合，每个集合实质上是个256长度的数组，名字翻译过来是（荒地，农庄，拜占庭，君士坦丁堡）估计是对应了EVM的四个发展阶段。指令集向前兼容。

  1. 	frontierInstructionSet       = NewFrontierInstructionSet()
  2. 	homesteadInstructionSet      = NewHomesteadInstructionSet()
  3. 	byzantiumInstructionSet      = NewByzantiumInstructionSet()
  4. 	constantinopleInstructionSet = NewConstantinopleInstructionSet()

具体每条指令结构如下，字段意思见注释。

  1. type operation struct {
  2. 	//对应的操作函数
  3. 	execute executionFunc
  4. 	// 操作对应的gas消耗
  5. 	gasCost gasFunc
  6. 	// 栈深度验证
  7. 	validateStack stackValidationFunc
  8. 	// 操作所需空间
  9. 	memorySize memorySizeFunc
  11. 	halts   bool // 运算中止
  12. 	jumps   bool // 跳转（for）
  13. 	writes  bool // 是否写入
  14. 	valid   bool // 操作是否有效
  15. 	reverts bool // 出错回滚
  16. 	returns bool // 返回
  17. }

按下面的ADD指令为例

  1. 定义
  2.     ADD: {
  3.         execute:       opAdd,
  4.         gasCost:       constGasFunc(GasFastestStep),
  5.         validateStack: makeStackFunc(2, 1),
  6.         valid:         true,
  7.     },

操作

不同的操作有所不同，操作对象根据指令不同可能影响栈，内存，statedb。

  1.     func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  2.         //弹出一个值，取出一个值（这个值依旧保存在栈上面，运算结束后这个值就改变成结果值）
  3.         x, y := stack.pop(), stack.peek()
  4.         //加运算
  5.         math.U256(y.Add(x, y))
  6.         //数值缓存
  7.         evm.interpreter.intPool.put(x)
  8.         return nil, nil
  9.     }

gas花费

不同的运算有不同的初始值和对应的运算方法，具体的方法都定义在gas_table里面。 按加法的为例，一次加操作固定耗费为3。

  1.     //固定耗费
  2.     func constGasFunc(gas uint64) gasFunc {
  3.         return func(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
  4.             return gas, nil
  5.         }
  6.     }

除此之外还有两个定义会影响gas的计算，通常作为量化的一个单位。

  1.     //file go-ethereum/core/vm/gas.go
  2.     const (
  3.         GasQuickStep   uint64 = 2
  4.         GasFastestStep uint64 = 3
  5.         GasFastStep    uint64 = 5
  6.         GasMidStep     uint64 = 8
  7.         GasSlowStep    uint64 = 10
  8.         GasExtStep     uint64 = 20
  10.         GasReturn       uint64 = 0
  11.         GasStop         uint64 = 0
  12.         GasContractByte uint64 = 200
  13.     )
  15.     //file go-ethereum/params/gas_table.go
  16.     type GasTable struct {
  17.         ExtcodeSize uint64
  18.         ExtcodeCopy uint64
  19.         Balance     uint64
  20.         SLoad       uint64
  21.         Calls       uint64
  22.         Suicide     uint64
  24.         ExpByte uint64
  26.         // CreateBySuicide occurs when the
  27.         // refunded account is one that does
  28.         // not exist. This logic is similar
  29.         // to call. May be left nil. Nil means
  30.         // not charged.
  31.         CreateBySuicide uint64
  32.     }

memorySize

因为加操作不需要申请内存因而memorySize为默认值0。

栈验证

先验证栈上的操作数够不够，再验证栈是否超出最大限制，加法在这里仅需验证其参数够不够，运算之后栈是要减一的。

  1.     func makeStackFunc(pop, push int) stackValidationFunc {
  2.         return func(stack *Stack) error {
  3.             //深度验证
  4.             if err := stack.require(pop); err != nil {
  5.                 return err
  6.             }
  7.             //最大值验证
  8.             //StackLimit       uint64 = 1024
  9.             if stack.len()+push-pop > int(params.StackLimit) {
  10.                 return fmt.Errorf("stack limit reached %d (%d)", stack.len(), params.StackLimit)
  11.             }
  12.             return nil
  13.         }
  14.     }

智能合约

合约是EVM智能合约的存储单位也是解释器执行的基本单位，包含了代码，调用人，所有人，gas相关的信息.

  1.     type Contract struct {
  2.         // CallerAddress is the result of the caller which initialised this
  3.         // contract. However when the "call method" is delegated this value
  4.         // needs to be initialised to that of the caller's caller.
  5.         CallerAddress common.Address
  6.         caller        ContractRef
  7.         self          ContractRef
  9.         jumpdests destinations // result of JUMPDEST analysis.
  11.         Code     []byte
  12.         CodeHash common.Hash
  13.         CodeAddr *common.Address
  14.         Input    []byte
  16.         Gas   uint64
  17.         value *big.Int
  19.         Args []byte
  21.         DelegateCall bool
  22.     }

EVM原生预编译了一批合约，定义在contracts.go里面。主要用于加密操作。

  1. // PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum
  2. // contracts used in the Byzantium release.
  3. var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
  4. 	common.BytesToAddress([]byte{1}): &ecrecover{},
  5. 	common.BytesToAddress([]byte{2}): &sha256hash{},
  6. 	common.BytesToAddress([]byte{3}): &ripemd160hash{},
  7. 	common.BytesToAddress([]byte{4}): &dataCopy{},
  8. 	common.BytesToAddress([]byte{5}): &bigModExp{},
  9. 	common.BytesToAddress([]byte{6}): &bn256Add{},
  10. 	common.BytesToAddress([]byte{7}): &bn256ScalarMul{},
  11. 	common.BytesToAddress([]byte{8}): &bn256Pairing{},
  12. }

执行机

栈

EVM中栈用于保存操作数，每个操作数的类型是big.int,这就是网上很多人说EVM是256位虚拟机的原因。执行opcode的时候，从上往下弹出操作数，作为操作的参数。

  1. type Stack struct {
  2. 	data []*big.Int
  3. }
  5. func (st *Stack) push(d *big.Int) {
  6. 	// NOTE push limit (1024) is checked in baseCheck
  7. 	//stackItem := new(big.Int).Set(d)
  8. 	//st.data = append(st.data, stackItem)
  9. 	st.data = append(st.data, d)
  10. }
  12. func (st *Stack) peek() *big.Int {
  13. 	return st.data[st.len()-1]
  14. }
  16. func (st *Stack) pop() (ret *big.Int) {
  17. 	ret = st.data[len(st.data)-1]
  18. 	st.data = st.data[:len(st.data)-1]
  19. 	return
  20. }

内存

内存用于一些内存操作（MLOAD,MSTORE,MSTORE8）及合约调用的参数拷贝（CALL，CALLCODE）。

内存数据结构，维护了一个byte数组，MLOAD，MSTORE读取存入的时候都要指定位置及长度才能准确的读写。

  1.     type Memory struct {
  2.         store       []byte
  3.         lastGasCost uint64
  4.     }
  6.     // Set sets offset + size to value
  7.     func (m *Memory) Set(offset, size uint64, value []byte) {
  8.         // length of store may never be less than offset + size.
  9.         // The store should be resized PRIOR to setting the memory
  10.         if size > uint64(len(m.store)) {
  11.             panic("INVALID memory: store empty")
  12.         }
  14.         // It's possible the offset is greater than 0 and size equals 0. This is because
  15.         // the calcMemSize (common.go) could potentially return 0 when size is zero (NO-OP)
  16.         if size > 0 {
  17.             copy(m.store[offset:offset+size], value)
  18.         }
  19.     }
  21.     func (self *Memory) Get(offset, size int64) (cpy []byte) {
  22.         if size == 0 {
  23.             return nil
  24.         }
  26.         if len(self.store) > int(offset) {
  27.             cpy = make([]byte, size)
  28.             copy(cpy, self.store[offset:offset+size])
  30.             return
  31.         }
  33.         return
  34.     }

内存操作

  1.     func opMload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  2.         offset := stack.pop()
  3.         val := evm.interpreter.intPool.get().SetBytes(memory.Get(offset.Int64(), 32))
  4.         stack.push(val)
  6.         evm.interpreter.intPool.put(offset)
  7.         return nil, nil
  8.     }
  10.     func opMstore(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  11.         // pop value of the stack
  12.         mStart, val := stack.pop(), stack.pop()
  13.         memory.Set(mStart.Uint64(), 32, math.PaddedBigBytes(val, 32))
  15.         evm.interpreter.intPool.put(mStart, val)
  16.         return nil, nil
  17.     }
  19.     func opMstore8(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  20.         off, val := stack.pop().Int64(), stack.pop().Int64()
  21.         memory.store[off] = byte(val & 0xff)
  23.         return nil, nil
  24.     }

stateDb

合约本身不保存数据，那么合约的数据是保存在哪里呢？合约及其调用类似于数据库的日志，保存了合约定义以及对他的一系列操作，只要将这些操作执行一遍就能获取当前的结果，但是如果每次都要去执行就太慢了，因而这部分数据是会持久化到stateDb里面的。code中定义了两条指令SSTORE SLOAD用于从db中读写合约当前的状态。

  1.     func opSload(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  2.         loc := common.BigToHash(stack.pop())
  3.         val := evm.StateDB.GetState(contract.Address(), loc).Big()
  4.         stack.push(val)
  5.         return nil, nil
  6.     }
  8.     func opSstore(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) {
  9.         loc := common.BigToHash(stack.pop())
  10.         val := stack.pop()
  11.         evm.StateDB.SetState(contract.Address(), loc, common.BigToHash(val))
  13.         evm.interpreter.intPool.put(val)
  14.         return nil, nil
  15.     }

执行过程

执行入口定义在evm.go中，功能就是组装执行环境（代码，执行人关系，参数等）。

  1.     func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
  2.         if evm.vmConfig.NoRecursion && evm.depth > 0 {
  3.             return nil, gas, nil
  4.         }
  6.         // 合约调用深度检查
  7.         if evm.depth > int(params.CallCreateDepth) {
  8.             return nil, gas, ErrDepth
  9.         }
  10.         // balance 检查
  11.         if !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
  12.             return nil, gas, ErrInsufficientBalance
  13.         }
  15.         var (
  16.             to       = AccountRef(addr)
  17.             //保存当前状态，如果出错，就回滚到这个状态
  18.             snapshot = evm.StateDB.Snapshot()
  19.         )
  20.         if !evm.StateDB.Exist(addr) {
  21.             //创建调用对象的stateObject
  22.             precompiles := PrecompiledContractsHomestead
  23.             if evm.ChainConfig().IsByzantium(evm.BlockNumber) {
  24.                 precompiles = PrecompiledContractsByzantium
  25.             }
  26.             if precompiles[addr] == nil && evm.ChainConfig().IsEIP158(evm.BlockNumber) && value.Sign() == 0 {
  27.                 return nil, gas, nil
  28.             }
  29.             evm.StateDB.CreateAccount(addr)
  30.         }
  31.         //调用别人合约可能需要花钱
  32.         evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value)
  34.         //创建合约环境
  35.         contract := NewContract(caller, to, value, gas)
  36.         contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr))
  38.         start := time.Now()
  40.         // Capture the tracer start/end events in debug mode
  41.         if evm.vmConfig.Debug && evm.depth == 0 {
  42.             evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value)
  44.             defer func() { // Lazy evaluation of the parameters
  45.                 evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err)
  46.             }()
  47.         }
  48.         //执行操作
  49.         ret, err = run(evm, contract, input)
  51.         // When an error was returned by the EVM or when setting the creation code
  52.         // above we revert to the snapshot and consume any gas remaining. Additionally
  53.         // when we're in homestead this also counts for code storage gas errors.
  54.         if err != nil {
  55.             //错误回滚
  56.             evm.StateDB.RevertToSnapshot(snapshot)
  57.             if err != errExecutionReverted {
  58.                 contract.UseGas(contract.Gas)
  59.             }
  60.         }
  61.         return ret, contract.Gas, err
  62.     }

类似的函数有四个。详细区别见最后的参考。

Call A->B A,B的环境独立

CallCode、 和Call类似 区别在于storage位置不一样

DelegateCall、 和CallCode类似，区别在于msg.send不一样

StaticCall 和call相似 只是不能修改状态

Contract和参数构造完成后调用执行函数，执行函数会检查调用的是否会之前编译好的原生合约，如果是原生合约则调用原生合约，否则调用解释器执行函数运算合约。

  1.     // run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter.
  2.     func run(evm *EVM, contract *Contract, input []byte) ([]byte, error) {
  3.         if contract.CodeAddr != nil {
  4.             precompiles := PrecompiledContractsHomestead
  5.             if evm.ChainConfig().IsByzantium(evm.BlockNumber) {
  6.                 precompiles = PrecompiledContractsByzantium
  7.             }
  8.             if p := precompiles[*contract.CodeAddr]; p != nil {
  9.                 return RunPrecompiledContract(p, input, contract)
  10.             }
  11.         }
  12.         return evm.interpreter.Run(contract, input)
  13.     }

解释器

  1.     func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err error) {
  3.         //返回数据
  4.         in.returnData = nil
  6.         var (
  7.             op    OpCode        // 当前指令
  8.             mem   = NewMemory() // 内存
  9.             stack = newstack()  // 栈
  10.             pc   = uint64(0)    // 指令位置
  11.             cost uint64         // gas花费
  12.             pcCopy  uint64      // debug使用
  13.             gasCopy uint64      // debug使用
  14.             logged  bool        // debug使用
  15.         )
  16.         contract.Input = input  //函数入参
  18.         //*****省略******
  20.         for atomic.LoadInt32(&in.evm.abort) == 0 {
  21.             //获取一条指令及指令对应的操作
  22.             op = contract.GetOp(pc)
  23.             operation := in.cfg.JumpTable[op]
  24.             //valid校验
  25.             if !operation.valid {
  26.                 return nil, fmt.Errorf("invalid opcode 0x%x", int(op))
  27.             }
  28.             //栈校验
  29.             if err := operation.validateStack(stack); err != nil {
  30.                 return nil, err
  31.             }
  32.             //修改检查
  33.             if err := in.enforceRestrictions(op, operation, stack); err != nil {
  34.                 return nil, err
  35.             }
  37.             var memorySize uint64
  38.             //计算内存 按操作所需要的操作数来算
  39.             if operation.memorySize != nil {
  40.                 memSize, overflow := bigUint64(operation.memorySize(stack))
  41.                 if overflow {
  42.                     return nil, errGasUintOverflow
  43.                 }
  44.                 //
  45.                 if memorySize, overflow = math.SafeMul(toWordSize(memSize), 32); overflow {
  46.                     return nil, errGasUintOverflow
  47.                 }
  48.             }
  49.             // 校验cost 调用前面提到的costfunc 计算本次操作cost消耗
  50.             cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize)
  51.             if err != nil || !contract.UseGas(cost) {
  52.                 return nil, ErrOutOfGas  //超出挂掉
  53.             }
  54.             if memorySize > 0 {
  55.                 //如果本次操作需要消耗memory ，扩展memory
  56.                 mem.Resize(memorySize)
  57.             }
  59.             // 执行操作
  60.             res, err := operation.execute(&pc, in.evm, contract, mem, stack)
  62.             if verifyPool {
  63.                 verifyIntegerPool(in.intPool)
  64.             }
  65.             // 如果遇到return 设置返回值
  66.             if operation.returns {
  67.                 in.returnData = res
  68.             }
  70.             switch {
  71.             case err != nil:
  72.                 return nil, err       //报错
  73.             case operation.reverts:   //出错回滚
  74.                 return res, errExecutionReverted
  75.             case operation.halts:
  76.                 return res, nil       //停止
  77.             case !operation.jumps:    //跳转
  78.                 pc++
  79.             }
  80.         }
  81.         return nil, nil
  82.     }

Solidity案例

和其他语言类似，有了字节码运行机，就可以在字节码上面再组织其他高级语言，而solidlity语言就是实现了这样的语言编译器，方便了合约编写，有利于推广以太坊dapp开发。

  1. pragma solidity ^0.4.17;
  3. contract simple {
  4.       uint num = 0;
  5.     function simple(){
  6.         num = 123;
  7.     }
  9.     function add(uint i) public returns(uint){
  10.         uint m = 111;
  11.         num =num * i+m;
  12.         return num;
  13.     } 
  15. }

生成的Opcodes码

JUMPDEST 函数入口

PUSH + JUMPI/JUMP 类似于调用函数

CALLDATASIZE + CALLDATALOAD 大约是获取函数参数

  1. .code
  2.   PUSH 80			contract simple {\n      uint ...
  3.   PUSH 40			contract simple {\n      uint ...
  4.   MSTORE 			contract simple {\n      uint ...
  5.   PUSH 0			0  //成员变量初始值
  6.   DUP1 			uint num = 0
  7.   //从下面这条指令可以看出，初始化的时候成员变量就会存到statedb里面去
  8.   SSTORE 			uint num = 0
  9.   CALLVALUE 			function simple(){\n        nu...
  10.   DUP1 			olidity ^
  11.   ISZERO 			a
  12.   PUSH [tag] 1			a
  13.   JUMPI 			a
  14.   PUSH 0			r
  15.   DUP1 			o
  16.   REVERT 			.17;\n
  17. contra
  18. tag 1			a
  19.   //下面部分是构造函数执行的部分
  20.   JUMPDEST 			a
  21.   POP 			function simple(){\n        nu...
  22.   PUSH 7B			123
  23.   PUSH 0			num
  24.   DUP2 			num = 123
  25.   SWAP1 			num = 123
  26.   //改变成员变量最后都会写入到statedb里面去
  27.   SSTORE 			num = 123
  28.   POP 			num = 123
  29.   PUSH #[$] 0000000000000000000000000000000000000000000000000000000000000000			contract simple {\n      uint ...
  30.   DUP1 			contract simple {\n      uint ...
  31.   PUSH [$] 0000000000000000000000000000000000000000000000000000000000000000			contract simple {\n      uint ...
  32.   PUSH 0			contract simple {\n      uint ...
  33.   CODECOPY 			contract simple {\n      uint ...
  34.   PUSH 0			contract simple {\n      uint ...
  35.   RETURN 			contract simple {\n      uint ...
  36.   //上面部分做完初始化之后并不会进入到runtime阶段
  37. .data
  38.   0:
  39.     .code
  40.       //下面这段代码大约是处理参数的
  41.       PUSH 80			contract simple {\n      uint ...
  42.       PUSH 40			contract simple {\n      uint ...
  43.       MSTORE 			contract simple {\n      uint ...
  44.       PUSH 4			contract simple {\n      uint ...
  45.       CALLDATASIZE 			contract simple {\n      uint ...
  46.       LT 			contract simple {\n      uint ...
  47.       PUSH [tag] 1			contract simple {\n      uint ...
  48.       JUMPI 			contract simple {\n      uint ...
  49.       PUSH 0			contract simple {\n      uint ...
  50.       CALLDATALOAD 			contract simple {\n      uint ...
  51.       PUSH 100000000000000000000000000000000000000000000000000000000			contract simple {\n      uint ...
  52.       SWAP1 			contract simple {\n      uint ...
  53.       DIV 			contract simple {\n      uint ...
  54.       PUSH FFFFFFFF			contract simple {\n      uint ...
  55.       AND 			contract simple {\n      uint ...
  56.       DUP1 			contract simple {\n      uint ...
  57.       PUSH 1003E2D2			contract simple {\n      uint ...
  58.       EQ 			contract simple {\n      uint ...
  59.       PUSH [tag] 2			contract simple {\n      uint ...
  60.       JUMPI 			contract simple {\n      uint ...
  61.     tag 1			contract simple {\n      uint ...
  62.       JUMPDEST 			contract simple {\n      uint ...
  63.       PUSH 0			contract simple {\n      uint ...
  64.       DUP1 			contract simple {\n      uint ...
  65.       REVERT 			contract simple {\n      uint ...
  66.     tag 2			function add(uint i) public re...
  67.       JUMPDEST 			function add(uint i) public re...
  68.       CALLVALUE 			function add(uint i) public re...
  69.       DUP1 			olidity ^
  70.       ISZERO 			a
  71.       PUSH [tag] 3			a
  72.       JUMPI 			a
  73.       PUSH 0			r
  74.       DUP1 			o
  75.       REVERT 			.17;\n
  76. contra
  77.     tag 3			a
  78.       JUMPDEST 			a
  79.       POP 			function add(uint i) public re...
  80.       PUSH [tag] 4			function add(uint i) public re...
  81.       PUSH 4			function add(uint i) public re...
  82.       DUP1 			function add(uint i) public re...
  83.       CALLDATASIZE 			function add(uint i) public re...
  84.       SUB 			function add(uint i) public re...
  85.       DUP2 			function add(uint i) public re...
  86.       ADD 			function add(uint i) public re...
  87.       SWAP1 			function add(uint i) public re...
  88.       DUP1 			function add(uint i) public re...
  89.       DUP1 			function add(uint i) public re...
  90.       CALLDATALOAD 			function add(uint i) public re...
  91.       SWAP1 			function add(uint i) public re...
  92.       PUSH 20			function add(uint i) public re...
  93.       ADD 			function add(uint i) public re...
  94.       SWAP1 			function add(uint i) public re...
  95.       SWAP3 			function add(uint i) public re...
  96.       SWAP2 			function add(uint i) public re...
  97.       SWAP1 			function add(uint i) public re...
  98.       POP 			function add(uint i) public re...
  99.       POP 			function add(uint i) public re...
  100.       POP 			function add(uint i) public re...
  101.       PUSH [tag] 5			function add(uint i) public re...
  102.       JUMP 			function add(uint i) public re...
  103.     tag 4			function add(uint i) public re...
  104.       JUMPDEST 			function add(uint i) public re...
  105.       PUSH 40			function add(uint i) public re...
  106.       MLOAD 			function add(uint i) public re...
  107.       DUP1 			function add(uint i) public re...
  108.       DUP3 			function add(uint i) public re...
  109.       DUP2 			function add(uint i) public re...
  110.       MSTORE 			function add(uint i) public re...
  111.       PUSH 20			function add(uint i) public re...
  112.       ADD 			function add(uint i) public re...
  113.       SWAP2 			function add(uint i) public re...
  114.       POP 			function add(uint i) public re...
  115.       POP 			function add(uint i) public re...
  116.       PUSH 40			function add(uint i) public re...
  117.       MLOAD 			function add(uint i) public re...
  118.       DUP1 			function add(uint i) public re...
  119.       SWAP2 			function add(uint i) public re...
  120.       SUB 			function add(uint i) public re...
  121.       SWAP1 			function add(uint i) public re...
  122.       RETURN 			function add(uint i) public re...
  123.     tag 5			function add(uint i) public re...
  124.       //函数内容
  125. JUMPDEST 			function add(uint i) public re...
  126.       //这下面就是函数的代码了
  127.       PUSH 0			uint //局部变量在栈里面
  128.       DUP1 			uint m
  129.       PUSH 6F			111
  130.       SWAP1 			uint m = 111
  131.       POP 			uint m = 111 //从push0到这里实现了定义局部变量并赋值
  132.       DUP1 			m
  133.       DUP4 			i            //获取参数
  134.       PUSH 0			num
  135.       SLOAD 			num      //上面那句和这句实现了读取成员变量
  136.       MUL 			num * i      //乘
  137.       ADD 			num * i+m    //加
  138.       PUSH 0			num
  139.       DUP2 			num =num * i+m
  140.       SWAP1 			num =num * i+m   //这三句赋值
  141.       SSTORE 			num =num * i+m   //成员变量存储
  142.       POP 			num =num * i+m
  143.       //下面几句实现return
  144.       PUSH 0			num
  145.       SLOAD 			num
  146.       SWAP2 			return num
  147.       POP 			return num
  148.       POP 			function add(uint i) public re...
  149.       SWAP2 			function add(uint i) public re...
  150.       SWAP1 			function add(uint i) public re...
  151.       POP 			function add(uint i) public re...
  152.       JUMP [out]			function add(uint i) public re...
  153.     .data

参考

Call、CallCode、DelegateCall：https://ethereum.stackexchange.com/questions/3667/difference-between-call-callcode-and-delegatecall

solidity结构：https://solidity.readthedocs.io/en/develop/structure-of-a-contract.html#

runtime bytecode和bytecode :https://ethereum.stackexchange.com/questions/13086/solc-bin-vs-bin-runtime/13087#13087

remix: https://remix.ethereum.org/

转自：（魂祭心）https://my.oschina.net/hunjixin/blog/1805306。

安利两个教程：1.以太坊入门实战 2.以太坊电商DApp实战

以太坊智能合约虚拟机(EVM)原理与实现的更多相关文章

  1. 以太坊智能合约介绍，Solidity介绍

    以太坊智能合约介绍,Solidity介绍 一个简单的智能合约 先从一个非常基础的例子开始,不用担心你现在还一点都不了解,我们将逐步了解到更多的细节. Storage contract SimpleSt ...

  2. 深入以太坊智能合约 ABI

    开发 DApp 时要调用在区块链上的以太坊智能合约,就需要智能合约的 ABI.本文希望更多了解 ABI,如为什么需要 ABI?如何解读 Ethereum 的智能合约 ABI?以及如何取得合约的 ABI ...

  3. 以太坊智能合约Hello World示例程序

    简介 以太坊(Ethereum)是一提供个智能合约(smart contract)功能的公共区块链(BlockChain)平台. 本文介绍了一个简单的以太坊智能合约的开发过程. 开发环境 在以太坊上开 ...

  4. 如何通过以太坊智能合约来进行众筹（ICO）

    前面我们有两遍文章写了如何发行代币,今天我们讲一下如何使用代币来公开募资,即编写一个募资合约. 写在前面 本文所讲的代币是使用以太坊智能合约创建,阅读本文前,你应该对以太坊.智能合约有所了解,如果你还 ...

  5. Go语言打造以太坊智能合约测试框架（level3）

    传送门: 柏链项目学院 第三课 智能合约自动化测试 之前课程回顾 我们之前介绍了go语言调用exec处理命令行,介绍了toml配置文件的处理,以及awk处理文本文件获得ABI信息.我们的代码算是完成了 ...

  6. Go语言打造以太坊智能合约测试框架（level1）

    传送门: 柏链项目学院 Go语言打造以太坊智能合约测试框架 前言 这是什么? 这是一个基于go语言编写的,自动化测试以太坊智能合约的开发框架,使用此框架,可以自动化的部署合约,自动测试合约内的功能函数 ...

  7. 以太坊智能合约 Solidity 的常用数据类型介绍

    目录 目录 1.数组 1.1.对数组的增删改查操作. 2.String.Bytes.Mapping的使用 3.Enums 和 Structs 的简单应用 4.Ether 单位和 Time 单位 5.A ...

  8. rpc接口调用以太坊智能合约

    rpc接口调用以太坊智能合约 传送门: 柏链项目学院   在以太坊摸爬滚打有些日子了,也遇到了各种各样的问题.这几天主要研究了一下如何通过rpc接口编译.部署和调用合约.也遇到了一些困难和问题,下面将 ...

  9. 使用web3.js监听以太坊智能合约event

    传送门: 柏链项目学院 使用web3.js监听以太坊智能合约event   当我们在前端页面调用合约时发现有些数据不会立即返回,这时还需要再调用更新数据的函数.那么这样的方法使用起来非常不便,监听ev ...

随机推荐

  1. J2EE进阶(二)从零开始之Struts2

    J2EE进阶(二)从零开始之Struts2 以前自己总是听说什么SSH框架,不明觉厉.现在自己要重整旗鼓,开始系统性的学习SSH框架了.首先开始Struts2的学习.其实自己之前参与过Struts2项 ...

  2. pig 的chararry类型不能用比较运算符comparison operator

    pig 的chararry类型可能是按字段,逐个字段进行比较. element_id 是chararray类型, 语句: no_app_category_mapping = filter no_ele ...

  3. Hadoop分布式存储系统HDFS

    1.hadoop fs 指令 -ls -ls <路径> 查看指定路径的当前目录结构 -lsr -lsr <路径> 递归查看指定路径的目录结构 -du -du <路径> ...

  4. Linux之使用网络

    Linux有好多命令可以让你方便的使用网络,常见的有ssh,rsync,wget,curl等等,但是telnet等方式并不适用于网络交互的使用,因为它会暴露你的用户名密码等.所以一般使用安全的命令来进 ...

  5. 如何在Git中撤销一切 | 干货

    翻译:李伟 审校:张帆 译自:Github JF杰微刊:如何在Git中撤销一切 任何一个版本控制系统中,最有用的特性之一莫过于 "撤销(undo)"操作.在Git中,"撤 ...

  6. html案例详解（一）

    一.入门. <html> <!-- 头信息的作用 1. 可以设置网页的标题. 2. 可以通知浏览使用指定的码表解释html页面. 3. --> <head> < ...

  7. （一）UI设计的一些常识

    一.概述 新版本的Xcode似乎框架不明示. UIView:屏幕上看得见摸得着的东西.视图.控件.组件. UIView是一个容器,能容纳其他UIView. UIViewController用来控制UI ...

  8. 《java入门第一季》之面向对象匿名内部类面试题

    面试题一: /*         按照要求,补齐代码             interface Inter { void show(); }             class Outer { // ...

  9. Java进阶(二十二)使用FileOutputStream写入文件

    Java使用FileOutputStream写入文件 绪 在Java中,文件输出流是一种用于处理原始二进制数据的字节流类.为了将数据写入到文件中,必须将数据转换为字节,并保存到文件.请参阅下面的完整的 ...

  10. 网站开发进阶(二十二)HTML UI知识汇总(更新中...)

    HTML知识汇总(更新中...) 1.<iframe> 标签 浏览器支持 所有浏览器都支持 <iframe> 标签. 定义和用法 iframe 元素会创建包含另外一个文档的内联 ...