Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

深入了解以太坊虚拟机

朋友一起走
167 0 0
Solidity提供了很多高级语言的抽象概念,但是这些特性让人很难明白在运行程序的时候到底发生了什么。我阅读了Solidity的文档,但依旧存在着几个基本的问题没有弄明白。/ ~. S/ D& g" @* t  q, r+ `

# O9 ~* y* i( l9 k0 b" sstring, bytes32, byte[], bytes之间的区别是什么?
, b- t( ^9 t6 g" U4 d- c
  `5 I+ s: H0 c该在什么地方使用哪个类型?
6 l3 i( N& U7 q& N) v9 b% F3 V& S( z8 `# P) o7 }  @% U: c8 Z
将 string 转换成bytes时会怎么样?可以转换成byte[]吗?$ G3 j6 h" t* D& u3 g% `) T

2 s$ F: W9 l$ p5 B6 Q它们的存储成本是多少?
, _5 i! c+ V6 \  h
$ j9 P4 r4 `6 O% \/ H0 ~5 ZEVM是如何存储映射( mappings)的?
8 U3 f) G4 q( p" w9 i: F# ~* R
7 ?, V% i- L8 ?' B为什么不能删除一个映射?- ]1 F. T) u- N3 k0 T4 A

& I7 t* _% {7 p  M& |可以有映射的映射吗?(可以,但是怎样映射?)- |! r, i7 Z8 C9 Z4 n) C. a

, I7 n6 z8 j( ?8 V; o为什么存在存储映射,但是却没有内存映射?! S. ]6 f) Y( d5 f" B1 I
, c# n! R. u, h6 g8 U
编译的合约在EVM看来是什么样子的?3 x3 R+ C% p! m

2 h1 O  e" }/ f合约是如何创建的?
. @  X1 U+ y7 T2 v- |' @& i1 t! t; n: k( ~; t& a0 o
到底什么是构造器?
. [# B: g- i% p1 L
! ]1 Q7 t  V$ J+ }; f
什么是 fallback 函数?
" g$ E) P- C7 |" J1 q( }1 n
$ |9 N5 W9 v! u# i+ p

3 ^) w0 M2 K: `" K9 T3 ]我觉得学习在以太坊虚拟机(EVM)上运行的类似Solidity 高级语言是一种很好的投资,有几个原因:
! M3 u% l; u- X6 T2 B0 RSolidity不是最后一种语言。更好的EVM语言正在到来。(拜托?)EVM是一个数据库引擎。要理解智能合约是如何以任意EVM语言来工作的,就必须要明白数据是如何被组织的,被存储的,以及如何被操作的。知道如何成为贡献者。以太坊的工具链还处于早期,理解EVM可以帮助你实现一个超棒的工具给自己和其他人使用。智力的挑战。EVM可以让你有个很好的理由在密码学、数据结构、编程语言设计的交集之间进行翱翔。在这个系列的文章中,我会拆开一个简单的Solidity合约,来让大家明白它是如何以EVM字节码(bytecode)来运行的。
% o, S  D# p& ^6 c/ D% V
! f6 s8 Q- r" u) k我希望能够学习以及会书写的文章大纲:
& J# Y9 ]% L1 b" I; v& o' iEVM字节码的基础认识不同类型(映射,数组)是如何表示的当一个新合约创建之后会发生什么当一个方法被调用时会发生什么ABI如何桥接不同的EVM语言我的最终目标是整体的理解一个编译的Solidity合约。让我们从阅读一些基本的EVM字节码开始。* R0 ?: M3 `% e/ u# ?' L. ]

+ [8 K( A. u, P5 d( v' qEVM指令集将是一个比较有帮助的参考。4 r! I, F- W4 v* r5 ~9 l! _! `
一个简单的合约1 a$ {% Y/ L6 j
我们的第一个合约有一个构造器和一个状态变量:7 ~- d8 |! v1 P) s7 Y' P
// c1.sol
0 w( @0 \- R" epragma solidity ^0.4.11;- m, F, j' s% x  S  e% p4 f4 ^! j8 f
contract C {
; Y5 r) u$ E4 R, w( e. x) T! T6 _    uint256 a;, ]% A: w. F/ L8 {
    function C() {
2 o, C4 o, ~, Y9 r: S6 p4 O$ H" Q      a = 1;
( F0 Z4 u) a) L    }
+ R4 }+ G) }5 d0 D5 m/ W, G1 q. P}
8 H% D; ?  G  t4 a+ d6 p用solc来编译此合约:& u- E9 h3 p' P- R* z/ L
$ solc --bin --asm c1.sol
5 s& V$ s& r/ k0 m======= c1.sol:C =======2 K4 L% a7 y' Z
EVM assembly:6 |+ b8 B* `/ K+ ^( W! R: y6 T
    /* "c1.sol":26:94  contract C {... */
. c& s% w' Y! N. C# s( X, x  mstore(0x40, 0x60)
) h  ~7 p5 b! \3 c    /* "c1.sol":59:92  function C() {... */
  ^& m4 @5 v1 j" I  jumpi(tag_1, iszero(callvalue))
7 ^' e6 G: m  _  0x01 k: P* m- f' j. R
  dup1
+ w5 k$ |7 {# `+ Y+ G  revert
  E' T( _) I: `  d: E' Jtag_1:
; E) [/ Q4 \, Y  _- ~4 B/ o! h* V7 Ftag_2:
; t( x( ?2 Z  a) V9 Q) d2 J" p    /* "c1.sol":84:85  1 */
" ^" e% d& m3 U+ |) _$ J& a# n  0x14 N, B1 N8 a0 H) ~1 M
    /* "c1.sol":80:81  a */
% V' ]0 P6 z; I6 `! s! I  0x0
$ r8 K$ ?: E3 [+ O: G4 I" o  O    /* "c1.sol":80:85  a = 1 */$ q8 _6 V* I8 T7 x& O1 G9 f
  dup2
, ~1 g* |5 E. B& T& B$ Z1 V; g  swap1
9 ~* m& v  |3 Q; g- X5 z, e" l/ U  sstore1 M  v# O  H& z+ N) _* j2 V: p# B
  pop
. m7 m: ~' @1 B8 @" B    /* "c1.sol":59:92  function C() {... */8 @# h9 ?  F& B- `2 I% z# |" d
tag_3:' J* e& d" E9 B& i8 X  b/ v5 J
    /* "c1.sol":26:94  contract C {... */
( N# E4 V& Q$ H$ Ztag_4:4 h: l1 M  l  M+ J/ T) i' P
  dataSize(sub_0)
+ P2 ]3 H. F$ j; u7 ?% r5 ?' A  dup1% h8 `5 N6 o& T! |& o
  dataOffset(sub_0)
& q1 y" A- `8 w. s3 {  0x0
6 v$ L" \7 N& H% U# Q) g  codecopy8 ^2 s7 y6 |* ]: c# t; p
  0x0
+ ?2 n7 W3 \( n$ F/ Q% o  D" W  return
$ J* }4 q/ H4 Kstop  J- N% C# o: B
sub_0: assembly {- B# ~& ]7 `% H' g" x  U, M, w3 G
        /* "c1.sol":26:94  contract C {... */6 f# n% a; e3 b0 W
      mstore(0x40, 0x60)
8 w2 H, O& \- M$ Y7 F+ A    tag_1:
( x! ~$ n6 z4 m. s8 b' G      0x0( U$ [$ p8 q8 B
      dup1
7 T" q) B, P( [+ l* z, }  h' ]: [4 k      revert9 ^$ R/ h, w8 z) C& w+ }
auxdata: 0xa165627a7a72305820af3193f6fd31031a0e0d2de1ad2c27352b1ce081b4f3c92b5650ca4dd542bb770029
, o) [4 A0 e% s/ B( O, E) b) F}
, |2 H5 V1 \: uBinary:/ r% g! x" y4 K' b4 A
60606040523415600e57600080fd5b5b60016000819055505b5b60368060266000396000f30060606040525b600080fd00a165627a7a72305820af3193f6fd31031a0e0d2de1ad2c27352b1ce081b4f3c92b5650ca4dd542bb770029! g3 J. _9 k5 b7 \( p7 x1 m, R
6060604052...这串数字就是EVM实际运行的字节码。
7 H/ D2 E. S; \5 q5 ?/ i8 H- i4 c6 t一小步一小步的来
! b5 I1 v% W2 P% a& }4 S: O上面一半的编译汇编是大多数Solidity程序中都会存在的样板语句。我们稍后再来看这些。现在,我们来看看合约中独特的部分,简单的存储变量赋值:& k) }' S  V" h- c6 _
a = 12 C& M; n5 g# L" f
代表这个赋值的字节码是6001600081905550。我们把它拆成一行一条指令:+ h; A' \' J- n- a; }5 |
60 01% Q. l8 O. G1 o) J: |  ?
60 00
& j9 @, Y) R9 T2 \* d  h81  i$ C/ m4 I* k( u2 M' y; a
90
' J; x' o! ]( t0 M# Z556 [: d1 Y! M( N0 t/ x7 n+ a9 E0 n0 C
50( K- F# E5 w, {! }$ e* X2 j$ V
EVM本质上就是一个循环,从上到下的执行每一条命令。让我们用相应的字节码来注释汇编代码(缩进到标签tag_2下),来更好的看看他们之间的关联:' e8 m4 V( J8 F5 h
tag_2:
0 K, Q% }, q4 b% ~+ i% O. @6 N  // 60 01
* a- ~. g2 b1 R' I7 v) d; H  0x1
* R/ I; R: k2 n" `7 w  // 60 00, }2 _4 `3 ~; P1 [" Y' `: m' v
  0x0
) o% R0 W: N+ j, ?. m  y  // 81! t) a$ G9 L% \: L3 _
  dup2
' E! ]) J/ }, d7 V1 D7 I  // 90
3 U* y2 r. K3 l$ c  swap1, S7 R' J9 y' J% _1 l2 O1 x  W
  // 55
) x" e: W' J) s5 p. g  sstore
  ~" \' b; x& |5 u  // 50: b1 [2 ]$ _9 r% D; f5 v* d1 R
  pop% P) _+ X3 u1 d/ W$ Q
注意0x1在汇编代码中实际上是push(0x1)的速记。这条指令将数值1压入栈中。8 j; U9 Q% P% {$ B: o( z
只是盯着它依然很难明白到底发生了什么,不过不用担心,一行一行的模拟EVM是比较简单的。
5 J7 B% I' z- u0 ?% y( k模拟EVM
; g7 Y1 A0 m1 c! Q% IEVM是个堆栈机器。指令可能会使用栈上的数值作为参数,也会将值作为结果压入栈中。让我们来思考一下add操作。% a0 s4 _3 \0 R+ P
假设栈上有两个值:, F  }. k; ^; F6 l. Y3 V8 Y
[1 2]% x, Z7 \( p, L
当EVM看见了add,它会将栈顶的2项相加,然后将答案压入栈中,结果是:
8 f. X8 J8 x$ X4 V0 C[3], b  k# V9 k" C7 C: x
接下来,我们用[]符号来标识栈:3 v* e7 ]" _) `2 O# H! ]
// 空栈
' k& C! ^  s3 F4 G( w* w' ]% f! Sstack: []4 D2 d4 n! T  p9 P& W
// 有3个数据的栈,栈顶项为3,栈底项为1
0 A: ^4 ^; E8 G  mstack: [3 2 1]
9 N" P# W( i$ y# P# f; e! Q. P: c用{}符号来标识合约存储器:
6 C" U8 z1 b$ l0 s// 空存储
2 m3 ]9 G  {+ e0 G4 B- m5 mstore: {}; h' Z3 L) r8 q6 O5 J$ D
// 数值0x1被保存在0x0的位置上
+ b( T8 E% u/ y& P' Y+ P+ j! Hstore: { 0x0 => 0x1 }9 f1 [; v/ ]! U0 `4 O2 t! p  L
现在让我们来看看真正的字节码。我们将会像EVM那样来模拟6001600081905550字节序列,并打印出每条指令的机器状态:3 ~' \% O1 F" H6 c  v1 B
// 60 01:将1压入栈中! ^/ s6 P# X" ]1 |2 b; s% o  l
0x1, P2 I' M; Z! F2 \- H
  stack: [0x1]/ ]/ Z* z4 y- i1 s4 K2 [  y4 t
// 60 00: 将0压入栈中, D7 \3 R* K; _' }0 }% E* Z
0x0
) z" i) l! y- k6 q4 L  stack: [0x0 0x1]$ j& @- U) t# |7 d) b- L7 m
// 81: 复制栈中的第二项
- g% N+ p4 I9 Ddup2
  }! w* `9 F1 r# a% h  stack: [0x1 0x0 0x1]; v! K" c. Z/ ]: y/ w, x
// 90: 交换栈顶的两项数据! h7 ^/ X/ g1 ^& H
swap1$ n% f8 f4 i! p# I  l
  stack: [0x0 0x1 0x1]% U, F6 b! b( E+ K3 n1 u
// 55: 将数值0x01存储在0x0的位置上
5 z1 s/ l2 ]9 Q// 这个操作会消耗栈顶两项数据
- K' R4 f) G, L+ ysstore
- R8 p) V" K7 {0 n) B8 r1 i  stack: [0x1]$ Z- q  Z2 Y; t: `( `. ]
  store: { 0x0 => 0x1 }
* W( M* d$ {; y* E% z3 g7 `0 T/ d// 50: pop (丢弃栈顶数据)
& o- h" n; S+ e  c$ N! d1 dpop
1 \' y" N( L0 c0 H+ M+ c  stack: []2 Y! q/ x  j% P3 K
  store: { 0x0 => 0x1 }
: f$ l" S# y3 ~' W5 q+ \最后,栈就为空栈,而存储器里面有一项数据。
( [5 V) o* }/ v! p( w; d值得注意的是Solidity已经决定将状态变量uint256 a保存在0x0的位置上。其他语言完全可以选择将状态变量存储在其他的任何位置上。
* d9 C( U+ u  v# T; s6001600081905550字节序列在本质上用EVM的操作伪代码来表示就是:
- ~) Y$ t8 h. w$ o+ f* L! n// a = 1
& ?. |2 O! S* H4 Y! isstore(0x0, 0x1)  p0 Q, l, _( N% X+ n
仔细观察,你就会发现dup2,swap1,pop都是多余的,汇编代码可以更简单一些:
& E) q. p' Y' l" S) M- c0 z0x16 \! K. M2 W! ^# Y# Y7 m
0x0
" a+ ^1 s( {9 K3 f/ J# y  t# z& Ksstore$ e  \5 C5 i/ d9 l
你可以模拟上面的3条指令,然后会发现他们的机器状态结果都是一样的:% y% g$ S- V) U  Y$ E
stack: []4 b, H/ L- s8 [4 ]  h, Z
store: { 0x0 => 0x1 }
4 [# s# w1 T( a5 K两个存储变量
6 N3 e) J( H" c让我们再额外的增加一个相同类型的存储变量:3 v; ?  k- f) ~* H1 p
// c2.sol( h6 Z5 b- C* Q, l# r& P
pragma solidity ^0.4.11;# n- j0 H1 A" p9 `, F2 S
contract C {
5 c3 Q; B+ Q: X% G/ y0 j    uint256 a;
1 d; n1 v8 t4 k$ t6 u1 Y    uint256 b;% {) a6 q" u) C8 P  u! y6 D" e
    function C() {
# l# c$ y- Z, s6 m7 S      a = 1;
/ l$ ~1 a# o8 X3 W      b = 2;
+ {/ T3 }4 _3 A/ p" n/ a    }
& P# b  g3 t8 ?; A}" g' h8 w) h0 l/ C" M
编译之后,主要来看tag_2:
! T  s% a2 N3 U* }$ solc --bin --asm c2.sol- G* ?: _% \4 t( O7 n. b: S
//前面的代码忽略了5 o- t+ f) @0 v- e
tag_2:
+ b1 k! }9 B0 t/ P2 V# p    /* "c2.sol":99:100  1 */7 K- q% Q* w! W3 s3 z) @
  0x1
& R' [% G8 @( T8 b4 [, e    /* "c2.sol":95:96  a */
3 p  v+ A1 M# e  0x0
2 A* x/ q! L! x: O# w/ i+ O4 a    /* "c2.sol":95:100  a = 1 */
. j% ~" h2 K- S1 N: R/ C  dup2
8 i) M# F0 z0 v4 d! B  swap1
+ P. x) X7 `$ o8 `5 t/ c+ A  sstore+ O# D; j* Z5 p# M; S
  pop
: e1 w9 I  w% c    /* "c2.sol":112:113  2 */
% w* {) X+ t. |& @' w  0x2
3 c2 ]' a+ m- }+ A    /* "c2.sol":108:109  b */3 ~6 C* N8 Y( f" V" r: ~, p$ q
  0x1( T6 V8 u5 b+ q0 R2 X8 p3 }
    /* "c2.sol":108:113  b = 2 */2 x+ l- h1 b* d/ q; ~
  dup2
3 K$ r# W6 Y& G( o& A: c/ \  swap17 {2 x0 A, w% q9 Q& M, s, Y; Y
  sstore' K! ]- g- \, B3 k) G
  pop6 V) {) S+ ^0 @
汇编的伪代码:
1 j/ o; n3 B) |7 C# U: O// a = 1
5 H1 A) J7 x7 [; csstore(0x0, 0x1)
: k! J+ C( w4 o7 k! N, H# ^5 f// b = 2
: l. N& \- V; ^; usstore(0x1, 0x2)0 V& [+ r, d6 I8 b6 g
我们可以看到两个存储变量的存储位置是依次排列的,a在0x0的位置而b在0x1的位置。
$ y" g5 Z  R1 S& w4 v存储打包
5 m* r" [" q, q每个存储槽都可以存储32个字节。如果一个变量只需要16个字节但是使用全部的32个字节会很浪费。Solidity为了高效存储,提供了一个优化方案:如果可以的话,就将两个小一点的数据类型进行打包然后存储在一个存储槽中。
5 L* l/ u- }! u' b! j/ P$ X8 B我们将a和b修改成16字节的变量:
: y% k' i3 S8 e3 F$ l! C( [pragma solidity ^0.4.11;
- z3 }+ w6 `7 ^; ?% o( S9 r6 |contract C {, h9 v' s1 k4 D
    uint128 a;& g& C4 ^7 a( O
    uint128 b;, b! Y- V" b1 C  w8 f' _$ C
    function C() {  m+ n' C: L# T7 o
      a = 1;
" _2 s% @2 k3 X: E! i9 w2 I( O      b = 2;
! w% B1 h2 U0 g) Q1 D4 Q0 ~- ^0 ?: O    }
8 J) [7 U  b8 z5 c$ w- v+ k}
0 x0 J) f" J" o# @0 U3 W编译此合约:" A3 |" v  v8 d, }& T& h
$ solc --bin --asm c3.sol
1 |1 p& M: E* |5 H: e3 U产生的汇编代码现在更加的复杂一些:5 L2 k5 l3 [, I# O3 q# \
tag_2:; q8 y8 E/ L7 ^0 [9 v# x
  // a = 1" \! Q/ u  f: D2 H! {
  0x1
% j, y- v* Q9 x* i/ ~& n  0x0
8 e# O( H) m2 c0 e8 f$ Z9 E: E6 s  dup1
' S% v3 n% x# \6 A  N7 W. B  0x100( x/ v( V% k! F) A7 a  @) r
  exp
+ |' `2 A' I8 X# D- g  dup2
, J7 H1 U2 ^) f+ c  sload0 S( v4 k3 D* C0 n
  dup2% g/ P3 ^" Q( c, S5 v# [, b& t% a
  0xffffffffffffffffffffffffffffffff) k* l# R5 k, Q
  mul
* t& r! L% {, u$ U  not
  P8 [* m2 I3 ~3 h  and9 d8 _+ M+ }4 R' v5 a9 e
  swap1
8 X6 r" f4 g' [1 L5 D- T+ `  dup4$ Y+ Q% @' ^3 ?6 L" P; F
  0xffffffffffffffffffffffffffffffff
# Y5 ?, ^8 N+ c* z" n) d  and
3 D/ R# C" ?5 z  mul
: B6 f) E, Y; B8 w  or
: b) Z/ ?- m* D* i4 u, M  N6 G  swap10 O7 R7 ~+ H% |7 Z
  sstore9 x7 `/ `8 y& i; t; }
  pop
  Z8 z% [  s7 G" u& t- ?  // b = 29 K# K" z& S5 K8 e2 T5 r) L
  0x2
  q6 u) Z- s7 z. T2 v! @  0x0
# W0 ^5 {  B5 L6 J9 t  0x10& o; H8 M* O+ v" d
  0x100; Z6 ~  \8 N7 n/ ~& g) E$ L
  exp2 h/ Z+ o* b, l2 p) a3 L- r
  dup2
/ X* D4 T7 f- [, M2 w1 b5 o6 }& y  sload5 {# U& l4 T, v! @3 U
  dup2* v3 j* a) @6 K( ?8 W! T8 {
  0xffffffffffffffffffffffffffffffff
# m1 A8 K, w4 E  mul3 A, Q8 ^9 _7 `9 P
  not
+ [& t" s9 D2 H' E# y. S& [  and  {5 ?  T2 O* p+ l* {3 v
  swap1
3 s4 |0 H$ B; \! x, S) j1 l  dup4
) l6 @  g! _& `( ^2 p& q  0xffffffffffffffffffffffffffffffff
2 c( @0 y) `  Z4 r$ a8 b& D, G  and3 U0 d# ]- m% P& V1 M( M
  mul( |" a) a5 ]' q
  or3 Z  y6 C- A, b% H! F4 `& H
  swap1) d: |9 M* F$ V) k, T
  sstore+ J2 j" K: I) g  b; v
  pop
  k# y% h0 ^9 L; M面的汇编代码将这两个变量打包放在一个存储位置(0x0)上,就像这样:2 z+ |: p  u7 y$ `5 O( O* t& f
[         b         ][         a         ]
' N, F2 C; u% `4 _& D. l[16 bytes / 128 bits][16 bytes / 128 bits], x* T7 s$ X2 b
进行打包的原因是因为目前最昂贵的操作就是存储的使用:1 ^( {! a& G6 h; {0 w
sstore指令第一次写入一个新位置需要花费20000 gassstore指令后续写入一个已存在的位置需要花费5000 gassload指令的成本是500 gas大多数的指令成本是3~10 gas
1 `$ [& _3 a5 R) ~0 m' [; x/ ^通过使用相同的存储位置,Solidity为存储第二个变量支付5000 gas,而不是20000 gas,节约了15000 gas。
+ j1 V% `, \& M3 Z' d

! O0 |- _) O! e$ L2 \更多优化) _0 j7 w' q$ [4 L5 H
应该可以将两个128位的数打包成一个数放入内存中,然后使用一个sstore指令进行存储操作,而不是使用两个单独的sstore命令来存储变量a和b,这样就额外的又省了5000 gas。% _- }* U1 j$ F
你可以通过添加optimize选项来让Solidity实现上面的优化:$ z& j& k, q6 Y0 \
$ solc --bin --asm --optimize c3.sol
$ r$ {7 H& j# o" |! @这样产生的汇编代码只有一个sload指令和一个sstore指令:
- ^2 N1 |5 G8 J/ ^* Atag_2:% _0 s# X2 d4 L+ O/ K0 a
    /* "c3.sol":95:96  a */  [8 x6 r9 R, x( w. R
  0x0
* N- j" Q9 u0 G6 a0 b! V2 e3 x    /* "c3.sol":95:100  a = 1 */8 k) c: m4 Z; V. s
  dup10 N" z9 k6 L4 ?; V; ^
  sload# B; D# u8 T/ G! A0 x: f2 h1 l
    /* "c3.sol":108:113  b = 2 */- ?; u: z' G7 r. k
  0x200000000000000000000000000000000
6 U1 u* T' t/ [  ^6 n2 r0 e  not(sub(exp(0x2, 0x80), 0x1))
. I% N7 s2 O# b# @+ }    /* "c3.sol":95:100  a = 1 */
) t' ^4 _3 z, X& i/ S" H, o5 S0 Q  swap1
! \" E  G6 Q3 @  swap2; a# y* I% }/ n  m. L7 z
  and
$ z! W$ n" m$ g5 l" o5 j    /* "c3.sol":99:100  1 */. k; R( A4 ^6 `$ H9 F9 V
  0x1
  q3 R/ N, \0 {# q% z+ G    /* "c3.sol":95:100  a = 1 */$ L/ K2 t: [& E1 Q; q4 W6 F. a
  or
' @7 Q, s) G# l0 p. J5 {  sub(exp(0x2, 0x80), 0x1)1 T" N. t% Z  U8 U1 K* z
    /* "c3.sol":108:113  b = 2 */
4 ?& Q3 V2 h8 d0 w9 N: R4 M  and6 s8 e3 {+ ~! ?
  or
7 Q: h) K) M3 P1 r" s  swap17 N8 Y7 N( a5 {) n! X: x* u5 A5 @
  sstore
4 S# h8 x5 f- J" U& s6 T) _; V8 f字节码是:
3 M) K8 M1 r# \" J, O600080547002000000000000000000000000000000006001608060020a03199091166001176001608060020a0316179055
' O1 u) Q* R4 V3 w将字节码解析成一行一指令:/ l" v! O" Y+ l. ]
// push 0x0
, c3 A9 U2 Q$ X2 P5 s" V4 p4 o60 009 }( `9 P2 [* |/ Y
// dup1
9 E) |( l$ T5 O7 H! Z4 L- `: [. r80
9 M0 u9 h2 Z  \8 @: w7 P" H// sload& }$ D- A! f( y& X
54
5 _* }0 x4 d' S// push17 将下面17个字节作为一个32个字的数值压入栈中
; e% _! n9 ~$ ?, i" N0 l: i70 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
. d7 o9 Q* |, r& t; w% ?/* not(sub(exp(0x2, 0x80), 0x1)) */
* h( y8 v/ E/ \. Q6 b// push 0x12 P2 ?" r7 X  w: a; p8 D  F
60 01, E8 ~$ w; o: X; ~. C
// push 0x80 (32)# W8 T& g5 v2 t1 `* @" r% T" |
60 805 P/ G8 d6 _% L3 A+ F
// push 0x80 (2)- N# A; `! x, V3 O% I. n
60 02
8 O3 P3 ^* U" L3 {// exp" A  E# r- ~8 C
0a5 O6 c+ B6 P9 s- \
// sub
9 k: k2 _3 y7 k; m# {% g+ i+ X03; Z# j7 K3 M! M8 x/ c9 v& g; T- p4 n) n
// not5 V5 R% n% N, T/ D( R) u8 E( Q
19
) C) I5 x- d  t+ V& i0 F// swap1
4 ~# Y# y5 y' h" x: |! L" q* q90
# o) O5 ~, Y! Z; _" ?// swap2
3 _. \+ f* G; T8 y91
& D' M2 c5 C- {3 T// and
9 }& d+ K! G6 E# w16$ g" a, j) {4 Z4 ^$ {$ k9 f3 a
// push 0x1
% m2 [& i4 s4 H: N60 01
6 X9 U$ i  [" z& z) @+ x  c8 I$ N3 y// or
2 }+ e* W/ ]8 X, Q$ H* u17
. {' w" z& w& J" C  ?# a9 i" ^/ Y7 R/* sub(exp(0x2, 0x80), 0x1) */
- Z; r1 j$ Z/ R3 X9 l$ `* T// push 0x1
& j/ Y/ t$ E) C  O: o2 m60 01
& b8 r3 I1 B$ o0 w- V( Q9 l// push 0x808 l* t1 h) L+ ]3 F( Q0 l& E$ G3 Y: ?- t
60 80
2 H* k7 _3 {5 H" Z" `0 T) ^// push 0x02
" f; j! G/ Q; J% z60 02
$ c! P; t5 f! j( A// exp' d; h  }9 _5 I  H( C8 i
0a
& n" P( l, P  o) }5 E+ C, A/ ?// sub9 A; ]& W0 N" R4 {4 {/ r. B+ \2 C
03
( n- l' q, ?! z! C4 p1 c) B// and5 t/ ~2 _+ q! C+ d( o4 a# u  e
16
4 V* ^; }! t6 n; ?2 ~, G' V// or
' L: M7 L3 t' L3 c: r2 N+ V7 U4 c17& [. h' b+ h& w0 l# B
// swap1% ^* b7 R6 m' `
90
3 W  r% w9 m& F+ M5 c// sstore
' o, R+ y; o6 a& B& s55- g2 y# S3 H; v
上面的汇编代码中使用了4个神奇的数值:
  u6 V# H6 E8 o5 k- R* k& K! R0 n0x1(16字节),使用低16字节
- C" f9 b2 A9 t  M- c$ H// 在字节码中表示为0x018 u0 r6 G; W- o5 k7 ]
16:32 0x00000000000000000000000000000000, T/ {9 P# w! u! z. ]
00:16 0x00000000000000000000000000000001" ^/ r! i) j5 ?, D. }
0x2(16字节),使用高16字节5 P* j7 u% H9 \) R5 Y) S
//在字节码中表示为0x200000000000000000000000000000000 * H* T; ]# e8 i- N4 b! ?
16:32 0x000000000000000000000000000000025 X" l+ X3 \% f( D" t% z
00:16 0x00000000000000000000000000000000' r! N. B3 u2 g- m" j7 e' w( K6 m
not(sub(exp(0x2, 0x80), 0x1))
! z/ i! J# f4 W4 X# i) X// 高16字节的掩码- _( Y7 Q$ E, R4 w" K
16:32 0x00000000000000000000000000000000
3 a5 d; D  H0 j: _1 @00:16 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF9 e' J3 h' A" g
sub(exp(0x2, 0x80), 0x1)
9 [9 X) [. `; @- F+ m2 ^# b7 V// 低16字节的掩码8 f" j$ v% e9 e9 N6 t. n7 {1 G
16:32 0x00000000000000000000000000000000 ; R; z+ w# m9 m: |
00:16 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
* q& V$ S3 J4 z代码将这些数值进行了一些位的转换来达到想要的结果:
2 U: Q; W, g2 |+ T% T" ^: E16:32 0x00000000000000000000000000000002
' }( ^6 H8 |% g2 ?5 k00:16 0x00000000000000000000000000000001& U/ h9 O) r- [" x
最后,该32字节的数值被保存在了0x0的位置上。
5 g+ \! ?% h+ E5 M( w) y6 I5 ^Gas 的使用
  S) \& ~  x: _600080547002000000000000000000000000000000006001608060020a03199091166001176001608060020a03161790554 {3 ~8 |7 n$ z& k0 ~  k, i. o
注意0x200000000000000000000000000000000被嵌入到了字节码中。但是编译器也可能选择使用exp(0x2, 0x81)指令来计算数值,这会导致更短的字节码序列。* m6 s) j" C( u1 L
但结果是0x200000000000000000000000000000000比exp(0x2, 0x81)更便宜。让我们看看与gas费用相关的信息:
( m( g  E$ ]9 o- i一笔交易的每个零字节的数据或代码费用为 4 gas
1 p: N# R3 v" Y% q一笔交易的每个非零字节的数据或代码的费用为 68 gas
4 `4 ]  S1 C( Z1 O来计算下两个表示方式所花费的gas成本:
" a2 o, s9 l2 }, C' i0x200000000000000000000000000000000字节码包含了很多的0,更加的便宜。
( K, H, ^* V0 m. T; v$ Z- F(1 68) + (32 4) = 196
9 q" |+ L6 U. L! a& Y& P4 M6 x608160020a字节码更短,但是没有0。
& S# c# ^- E& o( Q" x4 o) l2 X5 * 68 = 340
* M& b- z! D' f1 u更长的字节码序列有很多的0,所以实际上更加的便宜!
3 W# S, p* [- {) T% g总结
( b# {! Q  b7 U6 v0 `EVM的编译器实际上不会为字节码的大小、速度或内存高效性进行优化。相反,它会为gas的使用进行优化,这间接鼓励了计算的排序,让以太坊区块链可以更高效一点。; O6 D) A; q# ]5 M" V7 }5 G
我们也看到了EVM一些奇特的地方:
% f+ _# u" n! m- I% o( tEVM是一个256位的机器。以32字节来处理数据是最自然的持久存储是相当昂贵的Solidity编译器会为了减少gas的使用而做出相应的优化选择
& j" y7 [' ~# H7 H- l0 r3 IGas成本的设置有一点武断,也许未来会改变。当成本改变的时候,编译器也会做出不同的优化选择。
. t4 P: h6 w. h2 ]8 n9 }: o
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

朋友一起走 初中生
  • 粉丝

    0

  • 关注

    0

  • 主题

    16