Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

Solidity汇编开发简明教程

handii2006
166 0 0
在用Solidity开发以太坊智能合约时,使用汇编可以直接与EVM交互,降低 gas开销成本,更精细的控制智能合约的行为,因此值得Solidity开发者学习 并加以利用。本文是Solidity汇编开发的简明教程,旨在帮助你快速熟悉 如何在Solidity智能合约代码中嵌入汇编代码。8 C' B0 V" B' H, Q" D
以太坊虚拟机和堆栈结构机器; R5 M! ?  v! ^! C# k% i
以太坊虚拟机EVM有自己的指令集,该指令集中目前包含了 144个操作码,详情参考Geth源代码. R$ @( ]- _, f+ X% L0 _
这些指令是Solidity抽象出来的,可以在Solidity内联使用。例如:; [% e/ U! Z$ b; \
contract Assembler {   
& I; M+ O( a7 y, @  p  function do_something_cpu() public {
: l. @/ n# r( F+ T! ?; v    assembly {# r5 {, r+ J/ w! X) u
      // start writing evm assembler language
7 F6 `. z3 Q6 `2 f    }# {" {) L7 j6 v% g
  }) a; e; f! T# S# L5 @9 K$ x' z; e
}
, I- n) b* f+ r: IEVM是一个栈虚拟机,栈这种数据结构只允许两个操作:压入(PUSH)或弹出(POP)数据。 最后压入的数据位于栈顶,因此将被第一个弹出,这被称为后进先出 (LIFO:Last In, First Out):. u. {# T4 @1 d

, W8 B: O+ e. k/ w栈虚拟机将所有的操作数保存在栈上,关于栈虚拟机的详细信息 可以参考stack machine 基础/ B9 L* U5 q" g9 `8 Y0 M" d3 f
堆栈结构机器的操作码* `- a1 N% {3 ]0 p$ [2 \- e; V( K! z
为了能够解决实际问题,栈结构机器需要实现一些额外的指令,例如 ADD、SUBSTRACT等等。指令执行时通常会先从堆栈弹出一个或多个值作为参数, 再将执行结果压回堆栈。这通常被称为逆波兰表示法(RPN:Reverse Polish Notation):+ y" P- F  O8 ^+ f
a + b      // 标准表示法Infix
, w2 m8 {3 B4 X3 H: ka b add    // 逆波兰表示法RPN8 J. l  y* S$ [1 Z4 T. v9 d+ R
在Solidity合约中使用内联汇编# @7 r2 ?& ?' l9 d
可以在Solidity中使用assembly{}来嵌入汇编代码段,这被称为内联汇编:
$ `- X; {( v+ P8 vassembly {7 h3 R5 `+ A& Z6 ~& R$ S  ]
  // some assembly code here
, r  s+ o+ w* l/ W2 E}
& O, |7 K' o& d, F在assembly块内的代码开发语言被称为Yul,为了简化我们称其为 汇编或EVM汇编。
6 c' g$ e0 P" }, t2 o另一个需要注意的问题时,汇编代码块之间不能通信,也就是说在 一个汇编代码块里定义的变量,在另一个汇编代码块中不可以访问。 例如:
. {9 k' ^0 n# n7 x- n7 Qassembly {
/ o6 O, k7 @: ~! J    let x := 2
  T* z- a, d4 [' ~5 j}        
  t$ S% Q8 g$ K* t4 \% aassembly {
: j# E- J  x  ?; e0 O  x    let y := x          // Error
/ ~0 Z: q) o# Y3 l' t3 F5 t$ Q}6 u" ?# C" |+ E* G8 ?6 B
上面的代码编译时会报如下错误:. s4 ~0 L3 m4 W  a( T; B: Y
// DeclarationError: identifier not found
! N* M& B4 @$ F# }// let y := x9 T1 M. r9 T6 b5 t4 ?4 m8 E
// ^) k" r, O% H2 A" l5 y* n
下面的代码使用内联汇编代码计算函数的两个参数的和并返回结果:
  ~' U! F# ~' Z. ufunction addition(uint x, uint y) public pure returns (uint) {. ]% f) x  {5 L% H7 [4 N4 ?: [
  assembly {! h: I( A. n- v( c6 f! b
    let result := add(x, y)   // x + y
* C& g- q$ [/ j, o' k    mstore(0x0, result)       // 在内存中保存结果
! _( ^) z( @- K0 l8 p    return(0x0, 32)           // 从内存中返回32字节0 B8 o  G) r+ M' z
  }: v7 I% R, E, f
}; r( D# T( `* k1 F6 Z
让我们重写上面的代码,补充一些更详细的注释,以便说明每个指令 在EVM内部的运行原理。' I7 b3 S& E: t0 I* Z8 t
function addition(uint x, uint y) public pure returns (uint) { 0 v) B: J  Q- @( h) ?
  assembly {        - t1 K" b% \& G+ E
    // 创建一个新的变量result4 z$ K3 L+ `: ]+ E6 l
    //     -> 使用add操作码计算x+y
7 d+ y# w- e  l7 ]1 H. u7 C    //     -> 将计算结果赋值给变量result      
6 I+ j, B3 [4 N5 l  {6 f  y    let result := add(x, y)   // x + y   9 @% v* j  W% x
    : K  J7 C$ t& T4 b, f1 @9 w
    // 使用mstore操作码
/ X3 m/ V7 T. N    //     -> 将result变量的值存入内存
  Y0 C" u# m' }/ e/ @( x( [    //     -> 指定内存地址 0x0      9 @) P7 t$ H% F1 k0 o! C9 e5 w8 p1 B
    mstore(0x0, result)       // 将结果存入内存
0 d7 [5 O1 d6 _# h* g5 U   
7 [. E- }' n7 c4 m% m    // 从内存地址0x返回32字节
( `5 o0 i! ]9 [! {+ V0 i# \( o  i    return(0x0, 32)          ( ?; b  |- w4 J7 U, f" f. B
  }: |4 y; n- u2 M3 k' `
}
! ?& p' h# l; k! wSolidity汇编中的变量定义与赋值
( Y+ M' W# S% R. K2 S, A在Yul中,使用let关键字定义变量。使用:=操作符给变量赋值:& D" d# Z7 r- l: @+ g: z
assembly {
/ `; `7 O  S# o# L7 p  let x := 2
" T+ o: j9 o  n1 N% t9 @}
' S$ q4 ]) d+ i' f9 e如果没有使用:=操作符给变量赋值,那么该变量自动初始化为0值:7 G: l6 L/ ^6 F1 D
assembly {" L6 q9 _6 L' q7 q, @5 i
  let x           // 自动初始化为 x = 0
) x: ?/ L) V$ r  x := 5          // x 现在的值是5
9 w/ E. o7 [0 O' c, ]. B}
3 @" ~6 s: B1 N% [0 v) R+ N你可以使用复杂的表达式为变量赋值,例如:
- n- B" R& H& q  Zassembly {4 E8 H0 Q* a( G8 Z/ j
  let x := 7   R( C- k" t7 u9 c: ^9 o6 f
  let y := add(x, 3)
+ M1 C3 z  I5 P  let z := add(keccak256(0x0, 0x20), div(slength, 32))   
; X$ x: E. b5 w7 ^3 c3 U9 _  let n            
  t- a2 @# {) q' \, }6 h( }}6 }) _7 I1 E% L) y1 [6 V
Solidity汇编中let指令的运行机制6 H; `& J) f3 e# v5 P$ ?
在EVM的内部,let指令执行如下任务:4 N# |+ d3 ?) w3 z1 b+ u5 Q- A
创建一个新的堆栈槽位为变量保留该槽位当到达代码块结束时自动销毁该槽位; B+ |: H1 q5 n! L( [: }( _
) p4 f5 ?9 m/ e! m5 F  ~3 y( ~+ V
因此,使用let指令在汇编代码块中定义的变量,在该代码块 外部是无法访问的。
; V) @) n4 [) E2 u. Y% OSolidity汇编中的注释. {4 m/ ~- ?% f) g! W
在Yul汇编中注释的写法和Solidity一样,可以使用单行注释// 或多行注释/* */。例如:
# Q( b0 v( x9 U- s+ y4 O0 Gassembly {     
: x5 g0 ?1 H  m+ E$ s  T( D* X  // single line comment
/ Q' i( T& H) H; ]! p7 X$ |  /*5 B9 Z) x# f* h% d/ S9 I+ {
    Multi
! x) H# ]& F6 L. F2 v    line
' Y+ _! j! W3 l; b    comment
% [" G0 e9 @1 z" p7 ~; e: c7 `  */3 [% [' ?$ X8 G: l; p- y3 U& ~
}
* F% C/ x  I! g0 I$ P+ SSolidity汇编中的字面量
& j$ [8 X8 D0 H9 C( f  |在Solidity汇编中字面量的写法与Solidity一致。不过,字符串字面量 最多可以包含32个字符。& g/ c# {2 N2 S1 p2 Q8 x
assembly {    , P& p7 W5 v9 y
  let a := 0x123             // 16进制
8 \3 x2 W+ S% a! }  let b := 42                // 10进制7 [& [1 m4 j4 K
  let c := "hello world"     // 字符串, [; B" T" ~% v* J/ q
  let d := "very long string more than 32 bytes" // 超长字符串,错误!9 m2 F6 c9 a& m3 y# [
}
! J1 j# i0 D8 h4 oSolidity汇编中的块和作用范围
; D2 u* J7 K: G在Solidity汇编中,变量的作用范围遵循标准规则。一个块的范围使用 一对大括号标识。2 L- W" Y3 N7 W5 z* ?3 Z' J
在下面的示例中,y和z仅在定义所在块范围内有效。因此y变量的作用 范围是scope 1,z变量的作用范围是scope 2。
8 _+ P2 g- g" qassembly {     $ r! g. ~* p/ T3 B; i- R( G2 s
  let x := 3          // x在各处可见% X2 g8 V5 n' Z* x3 V
   
! u0 g1 m1 d$ q: f4 B  // Scope 1           
6 P/ \  d. j- M+ V  {         ; y  }8 k' M$ ]( `& n
    let y := x     // ok   
( f  q/ i) M- h8 q2 ~* O5 `  }  // 到此处会销毁y
9 |) B4 E, t. h- v/ [' l  // Scope 2   
3 A8 t1 F) d) [/ P  {        
( ?1 p5 A4 {# l( y# x7 i; m    let z := y     // Error   
6 p) e- y! k* k7 o! B3 y7 X  } // 到此处会销毁z; D, A' [/ W( r5 Z* y, \" X8 j
}
, @2 u6 v' N, z. D9 ]// DeclarationError: identifier not found, s) A/ G% ~1 [1 P
// let z := y
$ T0 j& Q" j: y9 b/ x- J+ c' h// ^+ a3 M% n! u8 _1 C' O
作用范围的唯一例外是函数和for循环,我们将在下面解释。# W  n! t2 Y% s9 h$ s% O, y
在Solidity汇编中使用函数的局部变量
1 a5 f( n: |3 {7 f, ^: M( W在Solidity汇编中,只需要使用变量名就可以访问局部变量, 无论该变量是定义在汇编块中,还是Solidity代码中,不过 变量必须是函数的局部变量:+ C% k2 ]- F! l1 o$ Q
function assembly_local_var_access() public pure {    & Q, y- w1 w5 W0 e# f
  uint b = 5;   
& `8 \$ H& C  U1 Z1 P0 A! F6 M  assembly {                // defined inside  an assembly block
. k, I7 g/ ~6 r# m* e      let x := add(2, 3)  
  O' _4 z2 f3 k5 K- R0 F7 z      let y := 10  
! d, {$ W7 t" I$ T5 {" R6 j0 ]      z := add(x, y)
- N, \. W. ~6 }  }    0 y! N% x0 Y. I! x+ j/ X) v* J4 A& b
  assembly {               // defined outside an assembly block
. c1 P0 F  W& Q7 F0 a      let x := add(2, 3)- U1 W6 N+ L# ~, I8 \! A, s
      let y := mul(x, b), \  r2 ?3 ]% s: w; D
  }
0 B/ x; |. _! S' ^/ _}
/ w* R; w# v; V9 N5 ^在Solidity汇编中使用for循环
( U1 |5 j2 k2 K' K: j6 r6 K- S先看一下Solidity中循环的使用。下面的Solidity函数代码中 计算变量的倍数n次,其中value和n是函数的参数:6 D1 u% J$ d! A: w( R
function for_loop_solidity(uint n, uint value) public pure returns(uint) {         
% K+ S  \7 W; S$ k. B6 r2 ?' G  for ( uint i = 0; i ! M+ k4 x  D8 y
等效的Solidity汇编代码如下:/ X5 N$ t) _9 w' o# U4 B5 s' }
function for_loop_assembly(uint n, uint value) public pure returns (uint) {   
) Y7 ?* r# M3 ?$ X. |% K* t  assembly {         
& ~6 T7 {9 {( j3 `% R3 |7 Q    for { let i := 0 } lt(i, n) { i := add(i, 1) } {
, G! ^& b( ?3 L      value := mul(2, value) 7 ^+ ]- U4 t) }* i2 x
    }  
. e% F, m/ e  g, H    mstore(0x0, value)
( d1 ~/ m+ p; Z3 m- v; P9 |    return(0x0, 32)
: L9 e9 G' Z- y+ g  }   $ p" z1 }- b  T
}
9 |* ?# w9 `! @5 G; S类似于其他开发语言中的for循环,在Solidity汇编中,for循环也包含 3个元素:3 C  h6 k( @' k& u1 d# T6 i1 e
初始化:let i := 0: x  q' b; a, X$ |
执行条件:lt(i, n) ,必须是函数风格表达式- D; _" C7 j5 k" a
迭代后续步骤:add(i, 1); P- q% X' F( ^" f0 N
注意:for循环中变量的作用范围略有不同。在初始化部分定义的变量 在循环的其他部分都有效。
8 [) ^/ Y# m& U5 {* q在Solidity汇编中使用while循环
0 f  j5 {1 ?( e/ S, t在Solidity汇编中实际上是没有while循环关键字的,但是可以使用 for循环实现同样的功能:只要留空for循环的初始化部分和迭代后续步骤即可。/ a$ }3 M8 j( k- I% v: H6 C( F
assembly {
! n7 K- q# j3 V1 f! @* h! E  let x := 0
2 c: y, w, y& W! s5 u+ H) F  let i := 0( }$ a# j9 u* C7 H
  for { } lt(i, 0x100) { } {     // 等价于:while(i
( r8 m  {" U# m在Solidity汇编中使用if语句& ^/ x8 Z8 K4 v5 ~% Z5 q5 c
Solidity内联汇编支持使用if语句来设置代码执行的条件,但是 没有其他语言中的else部分。+ V2 j8 m$ N2 u' R9 [
assembly {   
' q; ~# p) |0 I; I3 N/ t  if slt(x, 0) { x := sub(0, x) }  // Ok
8 ^; P5 d3 W1 g3 P  if eq(value, 0) revert(0, 0)     // Error, 需要大括号
, b7 |/ m( E4 k* H; e, `; B}" r; V3 v) l/ e( Q
if语句强制要求代码块使用大括号,即使需要保护的代码只有一行, 也需要使用大括号。这和solidity不同。
+ ]" W9 ]4 X, p* v如果需要在Solidity内联汇编中检查多种条件,可以考虑使用 switch语句。
( Z: G$ d6 e1 W, r在Solidity汇编中使用switch语句4 c1 a5 r* r3 A8 R: y: O" D: m
EVM汇编中也有switch语句,它将一个表达式的值于多个常量 进行对比,并选择相应的代码分支来执行。switch语句支持 一个默认分支default,当表达式的值不匹配任何其他分支条件时,将 执行默认分支的代码。0 U5 K* e8 e" n5 y$ A
assembly {
( N7 E- _2 f* ^' N0 U  let x := 0
. J8 ~/ r  h0 E. E+ g  switch calldataload(4)! S; v! M5 j" v: U
  case 0 {! V/ X+ s2 F# O1 J/ U
    x := calldataload(0x24)# Q3 q! T! s8 O2 Y9 r1 C
  }6 p9 `$ ^6 a+ a; {9 Z
  default {9 F( y5 F5 {* j' c2 w. s# q
    x := calldataload(0x44)
8 s; R4 v: [: z- y1 y% W! ^  }1 q4 P, G: H6 `5 d9 R
  sstore(0, div(x, 2))
% S% x% D8 U$ i6 v  ?# g}
4 m7 ]$ C, r0 A* X9 i: zswitch语句有一些限制:
4 ~/ C& ~: B. g$ p/ T+ m) z3 C. B分支列表不需要大括号,但是分支的代码块需要大括号, H5 m0 F+ u: g# H5 A
所有的分支条件值必须:1)具有相同的类型 2)具有不同的值
+ u, i2 r- o% p) H* f* B如果分支条件已经涵盖所有可能的值,那么不允许再出现default条件
# }$ N7 H& T0 j8 ?( Aassembly {            
9 h$ Y* Z$ D/ \8 l: r9 X/ B  F  |/ O  let x := 347 C9 r. A9 \. m% p) Y% A# o
           
5 T- x2 K& g; J5 A0 u  switch lt(x, 30), O) C% @; ?( h; N6 p
  case true {8 ]- b0 l" Y% U7 e; J+ o
      // do something% z0 z: }. c  ~% R! a2 O
  }8 H6 Y( m" \/ X
  case false {
1 J; y" H& u7 G) Y' y      // do something els
" {  X2 x, [  j% o7 _  }9 u/ w' k1 r0 U; n
  default {- J& U8 m& _$ |" q( E8 O$ t; L5 h1 t
      // 不允许! I: Y. i  v( B$ J8 x  ^3 [
  }            
( `+ L! W* B8 K" J" r6 |}5 u. `* P. T# J6 N
在Solidity汇编中使用函数
9 ~+ L- d" E  F5 u: s也可以在Solidity内联汇编中定义底层函数。调用这些自定义的函数 和使用内置的操作码一样。
7 T' x. [- y/ y& Y' V: @( F- ?) j; ?下面的汇编函数用来分配指定长度的内存,并返回内存指针pos:
# d& w0 M/ j; _7 ]( Yassembly {      F4 A* v2 w- a1 p* [1 B
  function allocate(length) -> pos {
9 G! m! o/ {( ^; a    pos := mload(0x40)# {7 C# t0 v0 t$ V3 N7 j2 r
    mstore(0x40, add(pos, length))
: b1 Q# b8 ~3 c% k  }   
7 y7 v- j/ S/ r& F  let free_memory_pointer := allocate(64)0 t1 V& J# O+ s: O
}5 w* y7 g* l! s7 e0 r' D
汇编函数的运行机制如下:
: D3 V: g; }" W* w5 l( q/ v从堆栈提取参数将结果压入堆栈和Solidity函数不同,不需要指定汇编函数的可见性,例如public或private, 因为汇编函数仅在定义所在的汇编代码块内有效。$ H1 f$ v2 z( n$ t( y' `
) {) d- E; S8 r) v& y
Solidity汇编中的操作码
! j  B/ C8 c' E0 V7 f5 U2 |: {2 ^- yEVM操作码可以分为以下几类:
) O- i6 [* q& M. v9 N  o算数和比较操作位操作密码学操作,目前仅包含keccak256环境操作,主要指与区块链相关的全局信息,例如blockhash或coinbase收款账号存储、内存和栈操作交易与合约调用操作停机操作日志操作- p: \) `; P& ]& h
详细的操作码可以查看Solidity文档。
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

handii2006 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    1