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

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

(module
  (memory $m32 1)
  (memory $m64 i64 1)

  (memory $m32p1 65536 (pagesize 1))
  (memory $m64p1 i64 65536 (pagesize 1))

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

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

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

  (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(i32 vmctx, i32, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i32 notrap aligned gv0+48
;;     gv2 = load.i32 notrap aligned can_move gv0+44
;;     sig0 = (i32 vmctx, i32, i32, i32) tail
;;     fn0 = colocated u805306368:2 sig0
;;
;;                                 block0(v0: i32, v1: i32, v2: i32, v3: i32):
;; @003c                               v6 = load.i32 notrap aligned v0+48
;; @003c                               v7 = uextend.i64 v2
;; @003c                               v8 = uextend.i64 v3
;; @003c                               v11 = iadd v7, v8
;; @003c                               v12 = uextend.i64 v6
;; @003c                               v13 = icmp ugt v11, v12
;; @003c                               trapnz v13, heap_oob
;; @003c                               v14 = load.i32 notrap aligned can_move v0+44
;; @003c                               v17 = iadd v14, v2
;; @0038                               v4 = iconst.i32 0
;; @003c                               call fn0(v0, v17, v4, v3)  ; v4 = 0
;; @003f                               jump block1
;;
;;                                 block1:
;; @003f                               return
;; }
;;
;; function u0:1(i32 vmctx, i32, i64, i64) tail {
;;     gv0 = vmctx
;;     gv1 = load.i32 notrap aligned gv0+56
;;     gv2 = load.i32 notrap aligned can_move gv0+52
;;     sig0 = (i32 vmctx, i32, i32, i32) tail
;;     fn0 = colocated u805306368:2 sig0
;;
;;                                 block0(v0: i32, v1: i32, v2: i64, v3: i64):
;; @0048                               v6 = load.i32 notrap aligned v0+56
;; @0048                               v7 = uadd_overflow_trap v2, v3, heap_oob
;; @0048                               v8 = uextend.i64 v6
;; @0048                               v9 = icmp ugt v7, v8
;; @0048                               trapnz v9, heap_oob
;; @0048                               v10 = load.i32 notrap aligned can_move v0+52
;; @0048                               v11 = ireduce.i32 v2
;; @0048                               v14 = iadd v10, v11
;; @0044                               v4 = iconst.i32 0
;; @0048                               v15 = ireduce.i32 v3
;; @0048                               call fn0(v0, v14, v4, v15)  ; v4 = 0
;; @004b                               jump block1
;;
;;                                 block1:
;; @004b                               return
;; }
;;
;; function u0:2(i32 vmctx, i32, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i32 notrap aligned gv0+64
;;     gv2 = load.i32 notrap aligned can_move gv0+60
;;     sig0 = (i32 vmctx, i32, i32, i32) tail
;;     fn0 = colocated u805306368:2 sig0
;;
;;                                 block0(v0: i32, v1: i32, v2: i32, v3: i32):
;; @0054                               v6 = load.i32 notrap aligned v0+64
;; @0054                               v7 = uextend.i64 v2
;; @0054                               v8 = uextend.i64 v3
;; @0054                               v11 = iadd v7, v8
;; @0054                               v12 = uextend.i64 v6
;; @0054                               v13 = icmp ugt v11, v12
;; @0054                               trapnz v13, heap_oob
;; @0054                               v14 = load.i32 notrap aligned can_move v0+60
;; @0054                               v17 = iadd v14, v2
;; @0050                               v4 = iconst.i32 0
;; @0054                               call fn0(v0, v17, v4, v3)  ; v4 = 0
;; @0057                               jump block1
;;
;;                                 block1:
;; @0057                               return
;; }
;;
;; function u0:3(i32 vmctx, i32, i64, i64) tail {
;;     gv0 = vmctx
;;     gv1 = load.i32 notrap aligned gv0+72
;;     gv2 = load.i32 notrap aligned can_move gv0+68
;;     sig0 = (i32 vmctx, i32, i32, i32) tail
;;     fn0 = colocated u805306368:2 sig0
;;
;;                                 block0(v0: i32, v1: i32, v2: i64, v3: i64):
;; @0060                               v6 = load.i32 notrap aligned v0+72
;; @0060                               v7 = uadd_overflow_trap v2, v3, heap_oob
;; @0060                               v8 = uextend.i64 v6
;; @0060                               v9 = icmp ugt v7, v8
;; @0060                               trapnz v9, heap_oob
;; @0060                               v10 = load.i32 notrap aligned can_move v0+68
;; @0060                               v11 = ireduce.i32 v2
;; @0060                               v14 = iadd v10, v11
;; @005c                               v4 = iconst.i32 0
;; @0060                               v15 = ireduce.i32 v3
;; @0060                               call fn0(v0, v14, v4, v15)  ; v4 = 0
;; @0063                               jump block1
;;
;;                                 block1:
;; @0063                               return
;; }
;;
;; function u0:4(i32 vmctx, i32, i32, i32) tail {
;;     gv0 = vmctx
;;     gv1 = load.i32 notrap aligned gv0+80
;;     gv2 = load.i32 notrap aligned readonly can_move gv0+76
;;     sig0 = (i32 vmctx, i32, i32, i32) tail
;;     fn0 = colocated u805306368:2 sig0
;;
;;                                 block0(v0: i32, v1: i32, v2: i32, v3: i32):
;; @006c                               v6 = load.i32 notrap aligned v0+80
;; @006c                               v7 = uextend.i64 v2
;; @006c                               v8 = uextend.i64 v3
;; @006c                               v11 = iadd v7, v8
;; @006c                               v12 = uextend.i64 v6
;; @006c                               v13 = icmp ugt v11, v12
;; @006c                               trapnz v13, heap_oob
;; @006c                               v14 = load.i32 notrap aligned readonly can_move v0+76
;; @006c                               v17 = iadd v14, v2
;; @0068                               v4 = iconst.i32 0
;; @006c                               call fn0(v0, v17, v4, v3)  ; v4 = 0
;; @006f                               jump block1
;;
;;                                 block1:
;; @006f                               return
;; }