wasmtime-cli 46.0.1

Command-line interface for Wasmtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

;;! target = 'x86_64'
;;! test = 'optimize'
;;! flags = '-Wcustom-page-sizes'

(module
  (memory $m32 1)
  (func $fill32 (param i32 i32)
    local.get 0
    i32.const 0
    local.get 1
    memory.fill $m32
  )

  (memory $m64 i64 1)
  (func $fill64 (param i64 i64)
    local.get 0
    i32.const 0
    local.get 1
    memory.fill $m64
  )

  (memory $m32p1 65536 (pagesize 1))
  (func $fill32p1 (param i32 i32)
    local.get 0
    i32.const 0
    local.get 1
    memory.fill $m32p1
  )

  (memory $m64p1 i64 65536 (pagesize 1))
  (func $fill64p1 (param i64 i64)
    local.get 0
    i32.const 0
    local.get 1
    memory.fill $m64p1
  )

  (memory $empty 0 0)
  (func $fill-empty (param i32 i32)
    local.get 0
    i32.const 0
    local.get 1
    memory.fill $empty
  )
)
;; function u0:0(i64 vmctx, i64, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly gv0+8
;;     gv2 = load.i64 notrap aligned gv1+24
;;     gv3 = vmctx
;;     gv4 = load.i64 notrap aligned gv3+96
;;     gv5 = load.i64 notrap aligned readonly can_move gv3+88
;;     sig0 = (i64 vmctx, i64, i32, i64) tail
;;     fn0 = colocated u805306368:2 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
;; @003c                               v6 = load.i64 notrap aligned v0+96
;; @003c                               v7 = uextend.i64 v2
;; @003c                               v8 = uextend.i64 v3
;; @003c                               v11 = iadd v7, v8
;; @003c                               v12 = icmp ugt v11, v6
;; @003c                               trapnz v12, heap_oob
;; @003c                               v13 = load.i64 notrap aligned readonly can_move v0+88
;; @003c                               v17 = iadd v13, v7
;; @0038                               v4 = iconst.i32 0
;; @003c                               call fn0(v0, v17, v4, v8)  ; v4 = 0
;; @003f                               jump block1
;;
;;                                 block1:
;; @003f                               return
;; }
;;
;; function u0:1(i64 vmctx, i64, i64, i64) tail {
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly gv0+8
;;     gv2 = load.i64 notrap aligned gv1+24
;;     gv3 = vmctx
;;     gv4 = load.i64 notrap aligned gv3+112
;;     gv5 = load.i64 notrap aligned can_move gv3+104
;;     sig0 = (i64 vmctx, i64, i32, i64) tail
;;     fn0 = colocated u805306368:2 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
;; @0048                               v6 = load.i64 notrap aligned v0+112
;; @0048                               v7 = uadd_overflow_trap v2, v3, heap_oob
;; @0048                               v8 = icmp ugt v7, v6
;; @0048                               trapnz v8, heap_oob
;; @0048                               v9 = load.i64 notrap aligned can_move v0+104
;; @0048                               v12 = iadd v9, v2
;; @0044                               v4 = iconst.i32 0
;; @0048                               call fn0(v0, v12, v4, v3)  ; v4 = 0
;; @004b                               jump block1
;;
;;                                 block1:
;; @004b                               return
;; }
;;
;; function u0:2(i64 vmctx, i64, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly gv0+8
;;     gv2 = load.i64 notrap aligned gv1+24
;;     gv3 = vmctx
;;     gv4 = load.i64 notrap aligned gv3+128
;;     gv5 = load.i64 notrap aligned readonly can_move gv3+120
;;     sig0 = (i64 vmctx, i64, i32, i64) tail
;;     fn0 = colocated u805306368:2 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
;; @0054                               v6 = load.i64 notrap aligned v0+128
;; @0054                               v7 = uextend.i64 v2
;; @0054                               v8 = uextend.i64 v3
;; @0054                               v11 = iadd v7, v8
;; @0054                               v12 = icmp ugt v11, v6
;; @0054                               trapnz v12, heap_oob
;; @0054                               v13 = load.i64 notrap aligned readonly can_move v0+120
;; @0054                               v17 = iadd v13, v7
;; @0050                               v4 = iconst.i32 0
;; @0054                               call fn0(v0, v17, v4, v8)  ; v4 = 0
;; @0057                               jump block1
;;
;;                                 block1:
;; @0057                               return
;; }
;;
;; function u0:3(i64 vmctx, i64, i64, i64) tail {
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly gv0+8
;;     gv2 = load.i64 notrap aligned gv1+24
;;     gv3 = vmctx
;;     gv4 = load.i64 notrap aligned gv3+144
;;     gv5 = load.i64 notrap aligned can_move gv3+136
;;     sig0 = (i64 vmctx, i64, i32, i64) tail
;;     fn0 = colocated u805306368:2 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
;; @0060                               v6 = load.i64 notrap aligned v0+144
;; @0060                               v7 = uadd_overflow_trap v2, v3, heap_oob
;; @0060                               v8 = icmp ugt v7, v6
;; @0060                               trapnz v8, heap_oob
;; @0060                               v9 = load.i64 notrap aligned can_move v0+136
;; @0060                               v12 = iadd v9, v2
;; @005c                               v4 = iconst.i32 0
;; @0060                               call fn0(v0, v12, v4, v3)  ; v4 = 0
;; @0063                               jump block1
;;
;;                                 block1:
;; @0063                               return
;; }
;;
;; function u0:4(i64 vmctx, i64, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly gv0+8
;;     gv2 = load.i64 notrap aligned gv1+24
;;     gv3 = vmctx
;;     gv4 = load.i64 notrap aligned gv3+160
;;     gv5 = load.i64 notrap aligned readonly can_move gv3+152
;;     sig0 = (i64 vmctx, i64, i32, i64) tail
;;     fn0 = colocated u805306368:2 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
;; @006c                               v6 = load.i64 notrap aligned v0+160
;; @006c                               v7 = uextend.i64 v2
;; @006c                               v8 = uextend.i64 v3
;; @006c                               v11 = iadd v7, v8
;; @006c                               v12 = icmp ugt v11, v6
;; @006c                               trapnz v12, heap_oob
;; @006c                               v13 = load.i64 notrap aligned readonly can_move v0+152
;; @006c                               v17 = iadd v13, v7
;; @0068                               v4 = iconst.i32 0
;; @006c                               call fn0(v0, v17, v4, v8)  ; v4 = 0
;; @006f                               jump block1
;;
;;                                 block1:
;; @006f                               return
;; }