暴露给接口和智能合约代码的编码格式如下; g0 s# L* [; C- K6 R
运行时长度编码格式
- \# s1 X/ P- M3 _（Runtime Length Encoding Format）5 a( L* e! r+ O* {( R

. y) _" {0 i0 B( @, l, E在区块链上，x86 所有的合约数据都使用运行时长度编码（Runtime Length Encoding，RLE）来表示 0 字节。而非零数据不被编码。当在字节流中遇到 0 时，它被编码成一个长度。该长度表示跟随它的零字节数。RLE 的长度为 0 是明确禁止的，其结果是生成无法包含在区块或内存池里的无效交易。
* i. Q  J0 ]. W  |) {) K8 n0 f0 G. C+ i8 n0 s! k
RLE 有效载荷的前缀是一个 32 bit 整数。其中 24 bit 是解码大小字段。如果解码大小与解码的有效载荷不完全匹配，则交易无效。其余 8 bit 保留为版本号，以便实现其他压缩格式。
0 M# |6 ]6 R: J: X, K
1 R! R, c9 A% ^& a$ X! `9 z注意，有效负载的大小可以在不分配额外内存的情况下进行验证。  p% O& k  S; c  m9 m) R) s7 e1 w$ a

: d; Q8 G6 p: u相关代码注释：
: ?* E6 L% T' \//格式：解码的有效载荷长度（uint32_t）| 有效载荷
+ F* f3 E4 i4 M. W6 B, N3 Z//压缩只压缩 0 字节数据  K( r; I; K( E3 i
//当在字节流中遇到 0x00 时，它用运行时长度编码
/ Y& X. p; l/ G5 i) s; e//编码示例：2 l- G( c4 K0 A7 F; D5 \
// 0x00 00 00 00 - > 0x00 04
, t7 M1 H8 O' i: c# _4 u// 0x00 - > 0x00 012 m/ k  S6 f8 T; r( r
// 0x00 00 - > 0x00 02
& f% H$ a' [$ e* U// 0x00（重复500次） - > 0x00 0xFF 0x00 0xF56 B6 B  h8 e) p3 M
//作为编码过程的一部分，有效载荷的前 32 bit 是前缀
! h" w* V; @. f* U( kRLE 编码将使用在其他任何格式之上。
' ~7 w9 d9 s& \+ J5 h: k
1 v' `8 U; Y% ^( X& k编码和解码的代码已包含在 x86Lib 中，不过在其他编程语言中实现都应该是很简单的。
1 n3 f7 d0 O( n  w! h) m1 ^由于目前长度字段没有提供任何好处，以后可能会移除掉。我们的初衷是使用内存分配配置文件而不是要多次手动来分配内存。但不管怎样，现在解码后的数据存储在 Qtum 的备份数据库中，可以实现一次性解码。
) e$ D% W* c6 B# V% D5 Y# _0 N
( n' n$ k" h' Y智能合约字节码格式/ O8 N) E* ?0 L' h. d2 h
（Smart contract bytecode format）
% }5 C: i! y2 \% o7 |% K7 ~在编码和存储合约的方式上，x86 VM 和 EVM 不一样。EVM 中是直接给出了操作码数组，然后执行这些操作码。它们决定了这些操作码和数据的哪一部分可以作为智能合约字节码实际存储在永久存储器中。
3 L/ a/ o. f- a! [
+ z7 c& f( m$ V1 k% H但在Qtum 的 x86 VM 中更为简单，也更容易理解。这是一种自定义二进制格式，分为选项（options，即智能合约配置信息等），初始化数据（initialized data）和代码（code）三个部分。整个二进制文件直接存储在永久存储器中。这可以避免在 EVM 合约里写合约保护程序的情况。尽管这在 EVM 中不太复杂，但是在 x86 中开发还这样写，就有点奇怪了。因为你可能要写两个完全独立的程序来防止地址内存错误等等。
) `3 Z. Z1 L+ g$ v8 P. T# C% y' ], [  |1 d4 i
x86Lib 测试平台提供了将 ELF 程序转换为这种自定义二进制格式的工具。由于 ELF 包含大量潜在的复杂性，我们不打算直接使用 ELF。不过大多数 ELF 程序解析起来也是相当简单的。所以我们没有实现类似“你不能在ELF中使用这些功能”来处理特殊情况，而是使用更简单的自定义格式，并提供转换工具。基于此，我们还可以提供对扁平二进制格式，PE和其他二进制格式的支持。
% P) z( y' m0 l' A+ J2 g8 [0 K) I$ W$ m2 X8 g( k" Q
自定义格式是一个扁平字节数组 + 一个前缀，前缀 map 保存了每个部分的长度：
: o! |" f7 X+ }& |- G, l1 c( Z//可用的数据字段只是一个扁平的数据字段，因此我们需要自定义格式来存储
+ U. d) A. m% v* u//代码，数据和选项
3 n7 h- w% z8 v( z2 z) E7 j" s//因此，它把 4 个 uint32 整数作为前缀。9 D6 G* U- F' I- z  e
//第一个是选项的大小，第二个是代码的大小，第三个是数据的大小
7 z; R* D5 F8 {4 K" F* K//第四个未使用（暂时），但保留用于填充和对齐0 X& O! y% w  ]* `! Y
struct ContractMapInfo {/ H2 z  e  `# l. `
   //这个结构是达成共识的关键 CONSENSUS-CRITICAL0 R* u9 D! ~; Z0 L1 @3 @1 k
   //不要添加或删除字段，也不要重新排序！
$ b2 ~0 r7 a  d5 e6 F/ D6 J2 Q0 n   uint32_t optionsSize;
" o. |8 R4 c+ Z, K& V) J1 ]   uint32_t codeSize;
# H" T4 M. F7 r/ A9 T   uint32_t dataSize;
% k- l0 I4 s! C" K* }8 @4 l   uint32_t reserved;+ R9 Z( V3 @/ h% A! h( V, E
} __attribute__((__packed__));
4 O$ l$ m0 W. }  q在这个前缀 map 后，就只剩下一个扁平的字节数组了。# D2 B$ A. R8 ~% I
$ d) [: v# a" }8 W( \2 a
具体过程：" T5 j/ T0 j1 h0 T- B" t2 c6 [+ G
LOCATION = 0，这是 ContractMapInfo 之后的第一个字节% `9 D  m( {6 X1 f
将选项数据复制到从 LOCATION 到 LOCATION + optionsSize 的缓冲区中。通过 optionsSize 移动 LOCATION 指针
7 n3 R1 o7 G4 F& Z2 Q9 \8 b, `" f将代码数据复制到从 LOCATION 到 LOCATION + codeSize 的缓冲区中。 通过 codeSize 移动 LOCATION 指针+ @5 T3 ?. ]9 t/ N/ W  w
以此类推......
% }; A" c+ l/ j; J2 F. K1 R  i& q8 x$ N+ x# Z
对每部分的说明：
+ y, r$ E) V) @& G$ g选项。由于当前未使用选项，optionsSize 必须为 0.之后它可能会包含依赖关系图，可信任的合约选项以及其他专用配置数据。除非选项明确指明，否则数据不会直接暴露给合约代码
# w2 E6 P. Z( m$ G( j- I  e- T代码是只读可执行代码。它目前最大为 1Mb，将被加载到合约的内存空间 0x1000 处。合约修改这部分内存的内容是不允许的。执行这部分以外的代码可能要额外的 gas，因为这可能使 JIT 和其他优化更加困难。现在这部分固定大小为1Mb，codeSize 之外的任何数据都设置为0。
# V9 N) f% j- w" w& \& C数据分初始化数据和读写数据。它也有1Mb的限制，将被加载到合约的内存空间 0x100000 处。在一些文档中，这部分存储也称为“临时存储器”。现在这部分空间固定大小为1Mb，dataSize 以外的任何数据都设置为0. 同时， ELF 文件的“.BSS”部分（未初始化的内存）放在内存区域的结尾部分，但由于没有与之关联的数据，所以没有必要向 VM 提供有关 .BSS 的任何信息。ELF文件转换器会检查数据大小+ bss 大小是否不超过1Mb。9 x" @4 V* l. d, ~. t; H2 f

$ V; x/ M$ F% G智能合约交易调用格式
) h: ]# y- o# ^- y(Smart contract transaction-call format)' n1 E! ]- X! K5 B3 y; J; `
合约有一个调用堆栈，可以用来发送参数调用合约以及调用合约返回数据。但是，就验证目的而言，一个交易中有大量数据实体是非常重要的。因此，智能合约交易调用格式中实际上只有1个数据字段（与目前 EVM 相同）。不过，提供ABI是为了简化智能合约的解析任务。当然也可以忽略这个ABI，只使用一个要传递的字节数组来代替。5 C1 k; }# i' N9 E  [8 I

, r* ^. E9 K0 g& S: n具体过程：
% f+ v! l& k: J" LLOCATION = 0，数据的第一个字节  q; S* s/ w6 h2 ~- b
从 LOCATION 读取 32 位整数，记作 SIZE) p. E2 n5 @4 n. g  f" F
LOCATION 增加 2（整数）
# l% L& e4 {8 A/ E. y8 `分配大小为 SIZE 的缓冲区，然后将内存从 LOCATION 复制到 LOCATION + SIZE: h) e  B( V8 {, N( z2 {( m
LOCATION 按 SIZE 递增
/ w! E8 s& N! D! K  |- N0 V! ^重复，直到没有数据% j: P2 a& E- n" S
系统调用接口
) l( ~$ z+ ^& X4 VQtum 的系统调用方式和 Linux 非常相似。它根本不使用堆栈，只使用寄存器。如果需要传比寄存器更多的参数，那么一个寄存器需要在某种结构中指向这些存有参数的内存区域。目前中断码 0x40 用于 Qtum 所有的系统调用。* v1 ]- K7 |' E1 X) ?% `

# n% e. K0 n  w, U3 ]调用寄存器：
8 c' g1 E# j, F# ?( g& k. K% JEAX - 系统调用码：
5 z( g  u# e( uEBX, ECX, EDX, ESI, EDI, EBP - 参数 1-6: Q0 E% M. q- v+ F- v
ESP, EFLAGS - 未使用" b6 X" k0 I6 d+ E& B
系统调用返回寄存器：6 S' O  N) s2 I8 M8 }" `
EAX - 返回值（0表示成功，不包括返回长度的操作）
4 O# b/ l! N2 t6 bEBX，ECX，EDX，ESI，EBP，ESP，EFLAGS - 未修改6 b' x) x+ e  p+ `8 I& v+ @
4 }8 t" J9 _9 j# x$ T
libqtum 封装了一个函数简化 C ABI 接口：$ J9 Y3 B2 H* m2 T( X
.global __qtum_syscall
, z' s7 Z5 U) x1 m% M: L  i* I( l// long syscall(long number, long p1, long p2, long p3, long p4, long p5, long p6)
; {6 g) z7 D) I1 Y5 }__qtum_syscall:- t3 V4 Y; @  c' T
push %ebp
  G+ g! n. `. U, K$ A mov %esp,%ebp
' m2 f/ Z2 M3 a# Y. A push %edi* u9 B4 @6 y5 _/ m4 \) D& c
push %esi
% D6 O: Z2 x0 X+ n7 B# T# @ push %ebx' H7 P% a: R- j* G. m5 X  A* A
mov 8+0*4(%ebp),%eax: [6 ~) c2 J, }: k
mov 8+1*4(%ebp),%ebx
" M  b+ |$ D, z1 i mov 8+2*4(%ebp),%ecx, c2 P8 C: D' Y
mov 8+3*4(%ebp),%edx7 h. K% g3 s9 I1 y) h& C
mov 8+4*4(%ebp),%esi
) d5 j# |# Q+ N- Z1 y9 z+ M mov 8+5*4(%ebp),%edi
' }0 g$ ^: E- G) V$ g$ o- M& X mov 8+6*4(%ebp),%ebp
' ?, M) w- M' u int $0x40  n- W! B. _2 F2 v5 U% Q) `" B
pop %ebx
4 |. L7 R% u; F8 v4 N+ N6 Z pop %esi4 m9 D1 T5 p- S0 t* q6 @) o4 U
pop %edi' s! c) @1 Q+ ~$ ~
pop %ebp" e% t2 A% \! w
ret4 E( `' U5 N$ F) @3 v

' W& G/ b) L/ F# n不过，因为 libqtum 为每个系统调用都封装了易用的函数，大多数人永远不用对系统调用执行任何操作。