1pub type U8 = ::core::ffi::c_uchar;
4pub type U32 = ::core::ffi::c_uint;
5pub type I32 = ::core::ffi::c_int;
6pub type U64 = ::core::ffi::c_ulonglong;
7pub type I64 = ::core::ffi::c_longlong;
8pub type F32 = f32;
9pub type F64 = f64;
10pub type wasmFunc = ::core::option::Option<unsafe extern "C" fn()>;
11pub type __m128i = [::core::ffi::c_longlong; 2usize];
12pub type SETJMP_FLOAT128 = _SETJMP_FLOAT128;
13pub type _JBTYPE = SETJMP_FLOAT128;
14#[repr(C)]
15#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
16pub struct wasmMemory {
17 pub data: *mut U8,
18 pub size: U32,
19 pub pages: U32,
20 pub maxPages: U32,
21 pub shared: bool,
22 pub futex: *mut ::core::ffi::c_void,
23 pub futexFree: ::core::option::Option<unsafe extern "C" fn(futex: *mut ::core::ffi::c_void)>,
24}
25#[repr(C)]
26#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
27pub struct wasmTable {
28 pub data: *mut wasmFunc,
29 pub size: U32,
30 pub maxSize: U32,
31}
32#[repr(C)]
33#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
34pub struct wasmFuncExport {
35 pub func: wasmFunc,
36 pub name: *mut ::core::ffi::c_char,
37}
38#[repr(C)]
39#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
40pub struct wasmModuleInstance {
41 pub funcExports: *mut wasmFuncExport,
42 pub resolveImports: ::core::option::Option<
43 unsafe extern "C" fn(
44 module: *const ::core::ffi::c_char,
45 name: *const ::core::ffi::c_char,
46 ) -> *mut ::core::ffi::c_void,
47 >,
48 pub newChild: ::core::option::Option<
49 unsafe extern "C" fn(self_: *mut wasmModuleInstance) -> *mut wasmModuleInstance,
50 >,
51}
52#[repr(C)]
53#[repr(align(16))]
54#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
55pub struct _SETJMP_FLOAT128 {
56 pub Part: [::core::ffi::c_ulonglong; 2usize],
57}
58#[repr(C)]
59#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
60pub struct Buffer {
61 pub data: *mut U8,
62 pub length: usize,
63}
64#[repr(transparent)]
65#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
66pub struct WasmValueType(pub ::core::ffi::c_int);
67#[repr(C)]
68#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
69pub struct WasmFunctionType {
70 pub parameterCount: U32,
71 pub parameterTypes: *mut WasmValueType,
72 pub resultCount: U32,
73 pub resultTypes: *mut WasmValueType,
74}
75#[repr(C)]
76#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
77pub struct WasmLocalsDeclaration {
78 pub type_: WasmValueType,
79 pub count: U32,
80}
81#[repr(C)]
82#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
83pub struct WasmLocalsDeclarations {
84 pub declarations: *mut WasmLocalsDeclaration,
85 pub declarationCount: U32,
86}
87#[repr(C)]
88#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
89pub struct WasmFunction {
90 pub functionTypeIndex: U32,
91 pub localsDeclarations: WasmLocalsDeclarations,
92 pub code: Buffer,
93 pub start: usize,
94 pub hash: [::core::ffi::c_uchar; 20usize],
95 pub exportName: *mut ::core::ffi::c_char,
96}
97#[repr(C)]
98#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
99pub struct WasmFunctionID {
100 pub hash: [::core::ffi::c_uchar; 20usize],
101 pub functionIndex: U32,
102}
103#[repr(C)]
104#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
105pub struct WasmFunctionIDs {
106 pub length: usize,
107 pub capacity: usize,
108 pub functionIDs: *mut WasmFunctionID,
109}
110#[repr(transparent)]
111#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
112pub struct WasmExportKind(pub ::core::ffi::c_int);
113#[repr(C)]
114#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
115pub struct WasmExport {
116 pub name: *mut ::core::ffi::c_char,
117 pub kind: WasmExportKind,
118 pub index: U32,
119}
120#[repr(C)]
121#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
122pub struct WasmGlobalType {
123 pub valueType: WasmValueType,
124 pub mutable: bool,
125}
126#[repr(C)]
127#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
128pub struct WasmGlobal {
129 pub type_: WasmGlobalType,
130 pub init: Buffer,
131}
132#[repr(transparent)]
133#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
134pub struct WasmImportKind(pub ::core::ffi::c_int);
135#[repr(C)]
136#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
137pub struct WasmFunctionImport {
138 pub module: *mut ::core::ffi::c_char,
139 pub name: *mut ::core::ffi::c_char,
140 pub functionTypeIndex: U32,
141}
142#[repr(C)]
143#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
144pub struct WasmFunctionImports {
145 pub length: usize,
146 pub capacity: usize,
147 pub imports: *mut WasmFunctionImport,
148}
149#[repr(C)]
150#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
151pub struct WasmGlobalImport {
152 pub module: *mut ::core::ffi::c_char,
153 pub name: *mut ::core::ffi::c_char,
154 pub globalType: WasmGlobalType,
155}
156#[repr(C)]
157#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
158pub struct WasmGlobalImports {
159 pub length: usize,
160 pub capacity: usize,
161 pub imports: *mut WasmGlobalImport,
162}
163#[repr(C)]
164#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
165pub struct WasmMemoryImport {
166 pub module: *mut ::core::ffi::c_char,
167 pub name: *mut ::core::ffi::c_char,
168 pub min: U32,
169 pub max: U32,
170 pub shared: bool,
171}
172#[repr(C)]
173#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
174pub struct WasmMemoryImports {
175 pub length: usize,
176 pub capacity: usize,
177 pub imports: *mut WasmMemoryImport,
178}
179#[repr(C)]
180#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
181pub struct WasmTableImport {
182 pub module: *mut ::core::ffi::c_char,
183 pub name: *mut ::core::ffi::c_char,
184 pub min: U32,
185 pub max: U32,
186 pub shared: bool,
187}
188#[repr(C)]
189#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
190pub struct WasmTableImports {
191 pub length: usize,
192 pub capacity: usize,
193 pub imports: *mut WasmTableImport,
194}
195#[repr(C)]
196#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
197pub struct WasmMemory {
198 pub min: U32,
199 pub max: U32,
200 pub shared: bool,
201}
202#[repr(C)]
203#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
204pub struct WasmDataSegment {
205 pub memoryIndex: U32,
206 pub offset: Buffer,
207 pub bytes: Buffer,
208 pub passive: bool,
209}
210#[repr(transparent)]
211#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
212pub struct WasmDataSegmentMode(pub ::core::ffi::c_int);
213#[repr(C)]
214#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
215pub struct WasmTable {
216 pub min: U32,
217 pub max: U32,
218 pub shared: bool,
219}
220#[repr(C)]
221#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
222pub struct WasmElementSegment {
223 pub tableIndex: U32,
224 pub offset: Buffer,
225 pub functionIndexCount: U32,
226 pub functionIndices: *mut U32,
227}
228#[repr(C)]
229#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
230pub struct WasmDebugSection {
231 pub name: *mut ::core::ffi::c_char,
232 pub buffer: Buffer,
233}
234#[repr(C)]
235#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
236pub struct WasmDebugSections {
237 pub length: usize,
238 pub capacity: usize,
239 pub debugSections: *mut WasmDebugSection,
240}
241#[repr(C)]
242#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
243pub struct WasmDebugLine {
244 pub address: U64,
245 pub path: *mut ::core::ffi::c_char,
246 pub number: U64,
247}
248#[repr(C)]
249#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
250pub struct WasmDebugLines {
251 pub length: usize,
252 pub capacity: usize,
253 pub debugLines: *mut WasmDebugLine,
254}
255#[repr(C)]
256#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
257pub struct WasmNames {
258 pub length: usize,
259 pub capacity: usize,
260 pub names: *mut *mut ::core::ffi::c_char,
261}
262#[repr(C)]
263#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
264pub struct WasmFunctionTypes {
265 pub functionTypes: *mut WasmFunctionType,
266 pub count: U32,
267}
268#[repr(C)]
269#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
270pub struct WasmFunctions {
271 pub functions: *mut WasmFunction,
272 pub count: U32,
273}
274#[repr(C)]
275#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
276pub struct WasmExports {
277 pub exports: *mut WasmExport,
278 pub count: U32,
279}
280#[repr(C)]
281#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
282pub struct WasmGlobals {
283 pub globals: *mut WasmGlobal,
284 pub count: U32,
285}
286#[repr(C)]
287#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
288pub struct WasmMemories {
289 pub memories: *mut WasmMemory,
290 pub count: U32,
291}
292#[repr(C)]
293#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
294pub struct WasmDataSegments {
295 pub dataSegments: *mut WasmDataSegment,
296 pub count: U32,
297}
298#[repr(C)]
299#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
300pub struct WasmTables {
301 pub tables: *mut WasmTable,
302 pub count: U32,
303}
304#[repr(C)]
305#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
306pub struct WasmElementSegments {
307 pub elementSegments: *mut WasmElementSegment,
308 pub count: U32,
309}
310#[repr(C)]
311#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
312pub struct WasmModule {
313 pub length: usize,
314 pub functionTypes: WasmFunctionTypes,
315 pub functions: WasmFunctions,
316 pub exports: WasmExports,
317 pub globals: WasmGlobals,
318 pub functionImports: WasmFunctionImports,
319 pub globalImports: WasmGlobalImports,
320 pub memoryImports: WasmMemoryImports,
321 pub memories: WasmMemories,
322 pub dataSegments: WasmDataSegments,
323 pub tableImports: WasmTableImports,
324 pub tables: WasmTables,
325 pub elementSegments: WasmElementSegments,
326 pub startFunctionIndex: U32,
327 pub hasStartFunction: bool,
328 pub debugSections: WasmDebugSections,
329 pub debugLines: WasmDebugLines,
330 pub functionNames: WasmNames,
331}
332#[repr(C)]
333#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
334pub struct WasmCWriteModuleOptions {
335 pub outputPath: *const ::core::ffi::c_char,
336 pub threadCount: U32,
337 pub functionsPerFile: U32,
338 pub pretty: bool,
339 pub debug: bool,
340 pub multipleModules: bool,
341 pub dataSegmentMode: WasmDataSegmentMode,
342}
343#[repr(transparent)]
344#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
345pub struct WasmOpcode(pub ::core::ffi::c_int);
346#[repr(transparent)]
347#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
348pub struct WasmMiscOpcode(pub ::core::ffi::c_int);
349#[repr(transparent)]
350#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
351pub struct WasmThreadsOpcode(pub ::core::ffi::c_int);
352#[repr(C)]
353#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
354pub struct WasmLocalInstruction {
355 pub localIndex: U32,
356}
357#[repr(C)]
358#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
359pub struct WasmGlobalInstruction {
360 pub globalIndex: U32,
361}
362#[repr(C)]
363#[derive(Copy, Clone)]
364pub struct WasmConstInstruction {
365 pub value: WasmValue,
366}
367#[repr(C)]
368#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
369pub struct WasmMemoryArgumentInstruction {
370 pub align: U32,
371 pub offset: U32,
372}
373#[repr(C)]
374#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
375pub struct WasmCallInstruction {
376 pub funcIndex: U32,
377}
378#[repr(C)]
379#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
380pub struct WasmCallIndirectInstruction {
381 pub functionTypeIndex: U32,
382 pub tableIndex: U32,
383}
384#[repr(C)]
385#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
386pub struct WasmBranchInstruction {
387 pub labelIndex: U32,
388}
389#[repr(C)]
390#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
391pub struct WasmBranchTableInstruction {
392 pub labelIndices: *mut U32,
393 pub labelIndexCount: U32,
394 pub defaultLabelIndex: U32,
395}
396#[repr(C)]
397#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
398pub struct WasmMemoryInstruction {
399 pub memoryIndex: U32,
400}
401#[repr(C)]
402#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
403pub struct WasmMemoryCopyInstruction {
404 pub memoryIndex1: U32,
405 pub memoryIndex2: U32,
406}
407#[repr(C)]
408#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
409pub struct WasmMemoryInitInstruction {
410 pub dataSegmentIndex: U32,
411 pub memoryIndex: U32,
412}
413#[repr(C)]
414#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
415pub struct WasmLabel {
416 pub index: U32,
417 pub typeStackLength: usize,
418 pub type_: *mut WasmValueType,
419}
420#[repr(C)]
421#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
422pub struct WasmLabels {
423 pub length: usize,
424 pub capacity: usize,
425 pub labels: *mut WasmLabel,
426}
427#[repr(C)]
428#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
429pub struct WasmLabelStack {
430 pub labels: WasmLabels,
431 pub nextLabelIndex: U32,
432}
433#[repr(C)]
434#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
435pub struct WasmModuleReader {
436 pub buffer: Buffer,
437 pub module: *mut WasmModule,
438 pub debug: bool,
439}
440#[repr(transparent)]
441#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
442pub struct WasmModuleReaderErrorCode(pub ::core::ffi::c_int);
443#[repr(C)]
444#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
445pub struct WasmModuleReaderError {
446 pub code: WasmModuleReaderErrorCode,
447}
448#[repr(transparent)]
449#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
450pub struct WasmSectionID(pub ::core::ffi::c_int);
451#[repr(transparent)]
452#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, ConstDefault)]
453pub struct WasmNameSubsectionID(pub ::core::ffi::c_int);
454#[repr(C)]
455#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
456pub struct StringBuilder {
457 pub string: *mut ::core::ffi::c_char,
458 pub length: usize,
459 pub capacity: usize,
460}
461#[repr(C)]
462#[derive(Debug, Copy, Clone, Hash, ConstDefault, TypedBuilder)]
463pub struct WasmTypeStack {
464 pub length: usize,
465 pub capacity: usize,
466 pub valueTypes: *mut WasmValueType,
467}
468pub const wasmTableTypeFuncRef: U8 = 112;
469#[repr(C)]
470#[derive(Copy, Clone)]
471pub union WasmValue {
472 pub i32_: I32,
473 pub i64_: I64,
474 pub f32_: F32,
475 pub f64_: F64,
476}
477impl WasmValueType {
478 pub const wasmValueTypeI32: WasmValueType = WasmValueType(0);
479 pub const wasmValueTypeI64: WasmValueType = WasmValueType(1);
480 pub const wasmValueTypeF32: WasmValueType = WasmValueType(2);
481 pub const wasmValueTypeF64: WasmValueType = WasmValueType(3);
482 pub const wasmValueType_count: WasmValueType = WasmValueType(4);
483}
484impl WasmExportKind {
485 pub const wasmExportKindFunction: WasmExportKind = WasmExportKind(0);
486 pub const wasmExportKindTable: WasmExportKind = WasmExportKind(1);
487 pub const wasmExportKindMemory: WasmExportKind = WasmExportKind(2);
488 pub const wasmExportKindGlobal: WasmExportKind = WasmExportKind(3);
489 pub const wasmExportKind_count: WasmExportKind = WasmExportKind(4);
490}
491impl WasmImportKind {
492 pub const wasmImportKindFunction: WasmImportKind = WasmImportKind(0);
493 pub const wasmImportKindTable: WasmImportKind = WasmImportKind(1);
494 pub const wasmImportKindMemory: WasmImportKind = WasmImportKind(2);
495 pub const wasmImportKindGlobal: WasmImportKind = WasmImportKind(3);
496 pub const wasmImportKind_count: WasmImportKind = WasmImportKind(4);
497}
498impl WasmDataSegmentMode {
499 pub const wasmDataSegmentModeArrays: WasmDataSegmentMode = WasmDataSegmentMode(0);
500 pub const wasmDataSegmentModeGNULD: WasmDataSegmentMode = WasmDataSegmentMode(1);
501 pub const wasmDataSegmentModeSectcreate1: WasmDataSegmentMode = WasmDataSegmentMode(2);
502 pub const wasmDataSegmentModeSectcreate2: WasmDataSegmentMode = WasmDataSegmentMode(3);
503}
504impl WasmOpcode {
505 pub const wasmOpcodeUnreachable: WasmOpcode = WasmOpcode(0);
506 pub const wasmOpcodeNop: WasmOpcode = WasmOpcode(1);
507 pub const wasmOpcodeBlock: WasmOpcode = WasmOpcode(2);
508 pub const wasmOpcodeLoop: WasmOpcode = WasmOpcode(3);
509 pub const wasmOpcodeIf: WasmOpcode = WasmOpcode(4);
510 pub const wasmOpcodeElse: WasmOpcode = WasmOpcode(5);
511 pub const wasmOpcodeEnd: WasmOpcode = WasmOpcode(11);
512 pub const wasmOpcodeBr: WasmOpcode = WasmOpcode(12);
513 pub const wasmOpcodeBrIf: WasmOpcode = WasmOpcode(13);
514 pub const wasmOpcodeBrTable: WasmOpcode = WasmOpcode(14);
515 pub const wasmOpcodeReturn: WasmOpcode = WasmOpcode(15);
516 pub const wasmOpcodeCall: WasmOpcode = WasmOpcode(16);
517 pub const wasmOpcodeCallIndirect: WasmOpcode = WasmOpcode(17);
518 pub const wasmOpcodeDrop: WasmOpcode = WasmOpcode(26);
519 pub const wasmOpcodeSelect: WasmOpcode = WasmOpcode(27);
520 pub const wasmOpcodeLocalGet: WasmOpcode = WasmOpcode(32);
521 pub const wasmOpcodeLocalSet: WasmOpcode = WasmOpcode(33);
522 pub const wasmOpcodeLocalTee: WasmOpcode = WasmOpcode(34);
523 pub const wasmOpcodeGlobalGet: WasmOpcode = WasmOpcode(35);
524 pub const wasmOpcodeGlobalSet: WasmOpcode = WasmOpcode(36);
525 pub const wasmOpcodeI32Load: WasmOpcode = WasmOpcode(40);
526 pub const wasmOpcodeI64Load: WasmOpcode = WasmOpcode(41);
527 pub const wasmOpcodeF32Load: WasmOpcode = WasmOpcode(42);
528 pub const wasmOpcodeF64Load: WasmOpcode = WasmOpcode(43);
529 pub const wasmOpcodeI32Load8S: WasmOpcode = WasmOpcode(44);
530 pub const wasmOpcodeI32Load8U: WasmOpcode = WasmOpcode(45);
531 pub const wasmOpcodeI32Load16S: WasmOpcode = WasmOpcode(46);
532 pub const wasmOpcodeI32Load16U: WasmOpcode = WasmOpcode(47);
533 pub const wasmOpcodeI64Load8S: WasmOpcode = WasmOpcode(48);
534 pub const wasmOpcodeI64Load8U: WasmOpcode = WasmOpcode(49);
535 pub const wasmOpcodeI64Load16S: WasmOpcode = WasmOpcode(50);
536 pub const wasmOpcodeI64Load16U: WasmOpcode = WasmOpcode(51);
537 pub const wasmOpcodeI64Load32S: WasmOpcode = WasmOpcode(52);
538 pub const wasmOpcodeI64Load32U: WasmOpcode = WasmOpcode(53);
539 pub const wasmOpcodeI32Store: WasmOpcode = WasmOpcode(54);
540 pub const wasmOpcodeI64Store: WasmOpcode = WasmOpcode(55);
541 pub const wasmOpcodeF32Store: WasmOpcode = WasmOpcode(56);
542 pub const wasmOpcodeF64Store: WasmOpcode = WasmOpcode(57);
543 pub const wasmOpcodeI32Store8: WasmOpcode = WasmOpcode(58);
544 pub const wasmOpcodeI32Store16: WasmOpcode = WasmOpcode(59);
545 pub const wasmOpcodeI64Store8: WasmOpcode = WasmOpcode(60);
546 pub const wasmOpcodeI64Store16: WasmOpcode = WasmOpcode(61);
547 pub const wasmOpcodeI64Store32: WasmOpcode = WasmOpcode(62);
548 pub const wasmOpcodeMemorySize: WasmOpcode = WasmOpcode(63);
549 pub const wasmOpcodeMemoryGrow: WasmOpcode = WasmOpcode(64);
550 pub const wasmOpcodeI32Const: WasmOpcode = WasmOpcode(65);
551 pub const wasmOpcodeI64Const: WasmOpcode = WasmOpcode(66);
552 pub const wasmOpcodeF32Const: WasmOpcode = WasmOpcode(67);
553 pub const wasmOpcodeF64Const: WasmOpcode = WasmOpcode(68);
554 pub const wasmOpcodeI32Eqz: WasmOpcode = WasmOpcode(69);
555 pub const wasmOpcodeI32Eq: WasmOpcode = WasmOpcode(70);
556 pub const wasmOpcodeI32Ne: WasmOpcode = WasmOpcode(71);
557 pub const wasmOpcodeI32LtS: WasmOpcode = WasmOpcode(72);
558 pub const wasmOpcodeI32LtU: WasmOpcode = WasmOpcode(73);
559 pub const wasmOpcodeI32GtS: WasmOpcode = WasmOpcode(74);
560 pub const wasmOpcodeI32GtU: WasmOpcode = WasmOpcode(75);
561 pub const wasmOpcodeI32LeS: WasmOpcode = WasmOpcode(76);
562 pub const wasmOpcodeI32LeU: WasmOpcode = WasmOpcode(77);
563 pub const wasmOpcodeI32GeS: WasmOpcode = WasmOpcode(78);
564 pub const wasmOpcodeI32GeU: WasmOpcode = WasmOpcode(79);
565 pub const wasmOpcodeI64Eqz: WasmOpcode = WasmOpcode(80);
566 pub const wasmOpcodeI64Eq: WasmOpcode = WasmOpcode(81);
567 pub const wasmOpcodeI64Ne: WasmOpcode = WasmOpcode(82);
568 pub const wasmOpcodeI64LtS: WasmOpcode = WasmOpcode(83);
569 pub const wasmOpcodeI64LtU: WasmOpcode = WasmOpcode(84);
570 pub const wasmOpcodeI64GtS: WasmOpcode = WasmOpcode(85);
571 pub const wasmOpcodeI64GtU: WasmOpcode = WasmOpcode(86);
572 pub const wasmOpcodeI64LeS: WasmOpcode = WasmOpcode(87);
573 pub const wasmOpcodeI64LeU: WasmOpcode = WasmOpcode(88);
574 pub const wasmOpcodeI64GeS: WasmOpcode = WasmOpcode(89);
575 pub const wasmOpcodeI64GeU: WasmOpcode = WasmOpcode(90);
576 pub const wasmOpcodeF32Eq: WasmOpcode = WasmOpcode(91);
577 pub const wasmOpcodeF32Ne: WasmOpcode = WasmOpcode(92);
578 pub const wasmOpcodeF32Lt: WasmOpcode = WasmOpcode(93);
579 pub const wasmOpcodeF32Gt: WasmOpcode = WasmOpcode(94);
580 pub const wasmOpcodeF32Le: WasmOpcode = WasmOpcode(95);
581 pub const wasmOpcodeF32Ge: WasmOpcode = WasmOpcode(96);
582 pub const wasmOpcodeF64Eq: WasmOpcode = WasmOpcode(97);
583 pub const wasmOpcodeF64Ne: WasmOpcode = WasmOpcode(98);
584 pub const wasmOpcodeF64Lt: WasmOpcode = WasmOpcode(99);
585 pub const wasmOpcodeF64Gt: WasmOpcode = WasmOpcode(100);
586 pub const wasmOpcodeF64Le: WasmOpcode = WasmOpcode(101);
587 pub const wasmOpcodeF64Ge: WasmOpcode = WasmOpcode(102);
588 pub const wasmOpcodeI32Clz: WasmOpcode = WasmOpcode(103);
589 pub const wasmOpcodeI32Ctz: WasmOpcode = WasmOpcode(104);
590 pub const wasmOpcodeI32PopCnt: WasmOpcode = WasmOpcode(105);
591 pub const wasmOpcodeI32Add: WasmOpcode = WasmOpcode(106);
592 pub const wasmOpcodeI32Sub: WasmOpcode = WasmOpcode(107);
593 pub const wasmOpcodeI32Mul: WasmOpcode = WasmOpcode(108);
594 pub const wasmOpcodeI32DivS: WasmOpcode = WasmOpcode(109);
595 pub const wasmOpcodeI32DivU: WasmOpcode = WasmOpcode(110);
596 pub const wasmOpcodeI32RemS: WasmOpcode = WasmOpcode(111);
597 pub const wasmOpcodeI32RemU: WasmOpcode = WasmOpcode(112);
598 pub const wasmOpcodeI32And: WasmOpcode = WasmOpcode(113);
599 pub const wasmOpcodeI32Or: WasmOpcode = WasmOpcode(114);
600 pub const wasmOpcodeI32Xor: WasmOpcode = WasmOpcode(115);
601 pub const wasmOpcodeI32Shl: WasmOpcode = WasmOpcode(116);
602 pub const wasmOpcodeI32ShrS: WasmOpcode = WasmOpcode(117);
603 pub const wasmOpcodeI32ShrU: WasmOpcode = WasmOpcode(118);
604 pub const wasmOpcodeI32Rotl: WasmOpcode = WasmOpcode(119);
605 pub const wasmOpcodeI32Rotr: WasmOpcode = WasmOpcode(120);
606 pub const wasmOpcodeI64Clz: WasmOpcode = WasmOpcode(121);
607 pub const wasmOpcodeI64Ctz: WasmOpcode = WasmOpcode(122);
608 pub const wasmOpcodeI64PopCnt: WasmOpcode = WasmOpcode(123);
609 pub const wasmOpcodeI64Add: WasmOpcode = WasmOpcode(124);
610 pub const wasmOpcodeI64Sub: WasmOpcode = WasmOpcode(125);
611 pub const wasmOpcodeI64Mul: WasmOpcode = WasmOpcode(126);
612 pub const wasmOpcodeI64DivS: WasmOpcode = WasmOpcode(127);
613 pub const wasmOpcodeI64DivU: WasmOpcode = WasmOpcode(128);
614 pub const wasmOpcodeI64RemS: WasmOpcode = WasmOpcode(129);
615 pub const wasmOpcodeI64RemU: WasmOpcode = WasmOpcode(130);
616 pub const wasmOpcodeI64And: WasmOpcode = WasmOpcode(131);
617 pub const wasmOpcodeI64Or: WasmOpcode = WasmOpcode(132);
618 pub const wasmOpcodeI64Xor: WasmOpcode = WasmOpcode(133);
619 pub const wasmOpcodeI64Shl: WasmOpcode = WasmOpcode(134);
620 pub const wasmOpcodeI64ShrS: WasmOpcode = WasmOpcode(135);
621 pub const wasmOpcodeI64ShrU: WasmOpcode = WasmOpcode(136);
622 pub const wasmOpcodeI64Rotl: WasmOpcode = WasmOpcode(137);
623 pub const wasmOpcodeI64Rotr: WasmOpcode = WasmOpcode(138);
624 pub const wasmOpcodeF32Abs: WasmOpcode = WasmOpcode(139);
625 pub const wasmOpcodeF32Neg: WasmOpcode = WasmOpcode(140);
626 pub const wasmOpcodeF32Ceil: WasmOpcode = WasmOpcode(141);
627 pub const wasmOpcodeF32Floor: WasmOpcode = WasmOpcode(142);
628 pub const wasmOpcodeF32Trunc: WasmOpcode = WasmOpcode(143);
629 pub const wasmOpcodeF32Nearest: WasmOpcode = WasmOpcode(144);
630 pub const wasmOpcodeF32Sqrt: WasmOpcode = WasmOpcode(145);
631 pub const wasmOpcodeF32Add: WasmOpcode = WasmOpcode(146);
632 pub const wasmOpcodeF32Sub: WasmOpcode = WasmOpcode(147);
633 pub const wasmOpcodeF32Mul: WasmOpcode = WasmOpcode(148);
634 pub const wasmOpcodeF32Div: WasmOpcode = WasmOpcode(149);
635 pub const wasmOpcodeF32Min: WasmOpcode = WasmOpcode(150);
636 pub const wasmOpcodeF32Max: WasmOpcode = WasmOpcode(151);
637 pub const wasmOpcodeF32CopySign: WasmOpcode = WasmOpcode(152);
638 pub const wasmOpcodeF64Abs: WasmOpcode = WasmOpcode(153);
639 pub const wasmOpcodeF64Neg: WasmOpcode = WasmOpcode(154);
640 pub const wasmOpcodeF64Ceil: WasmOpcode = WasmOpcode(155);
641 pub const wasmOpcodeF64Floor: WasmOpcode = WasmOpcode(156);
642 pub const wasmOpcodeF64Trunc: WasmOpcode = WasmOpcode(157);
643 pub const wasmOpcodeF64Nearest: WasmOpcode = WasmOpcode(158);
644 pub const wasmOpcodeF64Sqrt: WasmOpcode = WasmOpcode(159);
645 pub const wasmOpcodeF64Add: WasmOpcode = WasmOpcode(160);
646 pub const wasmOpcodeF64Sub: WasmOpcode = WasmOpcode(161);
647 pub const wasmOpcodeF64Mul: WasmOpcode = WasmOpcode(162);
648 pub const wasmOpcodeF64Div: WasmOpcode = WasmOpcode(163);
649 pub const wasmOpcodeF64Min: WasmOpcode = WasmOpcode(164);
650 pub const wasmOpcodeF64Max: WasmOpcode = WasmOpcode(165);
651 pub const wasmOpcodeF64CopySign: WasmOpcode = WasmOpcode(166);
652 pub const wasmOpcodeI32WrapI64: WasmOpcode = WasmOpcode(167);
653 pub const wasmOpcodeI32TruncF32S: WasmOpcode = WasmOpcode(168);
654 pub const wasmOpcodeI32TruncF32U: WasmOpcode = WasmOpcode(169);
655 pub const wasmOpcodeI32TruncF64S: WasmOpcode = WasmOpcode(170);
656 pub const wasmOpcodeI32TruncF64U: WasmOpcode = WasmOpcode(171);
657 pub const wasmOpcodeI64ExtendI32S: WasmOpcode = WasmOpcode(172);
658 pub const wasmOpcodeI64ExtendI32U: WasmOpcode = WasmOpcode(173);
659 pub const wasmOpcodeI64TruncF32S: WasmOpcode = WasmOpcode(174);
660 pub const wasmOpcodeI64TruncF32U: WasmOpcode = WasmOpcode(175);
661 pub const wasmOpcodeI64TruncF64S: WasmOpcode = WasmOpcode(176);
662 pub const wasmOpcodeI64TruncF64U: WasmOpcode = WasmOpcode(177);
663 pub const wasmOpcodeF32ConvertI32S: WasmOpcode = WasmOpcode(178);
664 pub const wasmOpcodeF32ConvertI32U: WasmOpcode = WasmOpcode(179);
665 pub const wasmOpcodeF32ConvertI64S: WasmOpcode = WasmOpcode(180);
666 pub const wasmOpcodeF32ConvertI64U: WasmOpcode = WasmOpcode(181);
667 pub const wasmOpcodeF32DemoteF64: WasmOpcode = WasmOpcode(182);
668 pub const wasmOpcodeF64ConvertI32S: WasmOpcode = WasmOpcode(183);
669 pub const wasmOpcodeF64ConvertI32U: WasmOpcode = WasmOpcode(184);
670 pub const wasmOpcodeF64ConvertI64S: WasmOpcode = WasmOpcode(185);
671 pub const wasmOpcodeF64ConvertI64U: WasmOpcode = WasmOpcode(186);
672 pub const wasmOpcodeF64PromoteF32: WasmOpcode = WasmOpcode(187);
673 pub const wasmOpcodeI32ReinterpretF32: WasmOpcode = WasmOpcode(188);
674 pub const wasmOpcodeI64ReinterpretF64: WasmOpcode = WasmOpcode(189);
675 pub const wasmOpcodeF32ReinterpretI32: WasmOpcode = WasmOpcode(190);
676 pub const wasmOpcodeF64ReinterpretI64: WasmOpcode = WasmOpcode(191);
677 pub const wasmOpcodeI32Extend8S: WasmOpcode = WasmOpcode(192);
678 pub const wasmOpcodeI32Extend16S: WasmOpcode = WasmOpcode(193);
679 pub const wasmOpcodeI64Extend8S: WasmOpcode = WasmOpcode(194);
680 pub const wasmOpcodeI64Extend16S: WasmOpcode = WasmOpcode(195);
681 pub const wasmOpcodeI64Extend32S: WasmOpcode = WasmOpcode(196);
682 pub const wasmOpcodeThreadsPrefix: WasmOpcode = WasmOpcode(254);
683 pub const wasmOpcodeMiscPrefix: WasmOpcode = WasmOpcode(252);
684}
685impl WasmMiscOpcode {
686 pub const wasmMiscOpcodeI32TruncSatF32S: WasmMiscOpcode = WasmMiscOpcode(0);
687 pub const wasmMiscOpcodeI32TruncSatF32U: WasmMiscOpcode = WasmMiscOpcode(1);
688 pub const wasmMiscOpcodeI32TruncSatF64S: WasmMiscOpcode = WasmMiscOpcode(2);
689 pub const wasmMiscOpcodeI32TruncSatF64U: WasmMiscOpcode = WasmMiscOpcode(3);
690 pub const wasmMiscOpcodeI64TruncSatF32S: WasmMiscOpcode = WasmMiscOpcode(4);
691 pub const wasmMiscOpcodeI64TruncSatF32U: WasmMiscOpcode = WasmMiscOpcode(5);
692 pub const wasmMiscOpcodeI64TruncSatF64S: WasmMiscOpcode = WasmMiscOpcode(6);
693 pub const wasmMiscOpcodeI64TruncSatF64U: WasmMiscOpcode = WasmMiscOpcode(7);
694 pub const wasmMiscOpcodeMemoryInit: WasmMiscOpcode = WasmMiscOpcode(8);
695 pub const wasmMiscOpcodeDataDrop: WasmMiscOpcode = WasmMiscOpcode(9);
696 pub const wasmMiscOpcodeMemoryCopy: WasmMiscOpcode = WasmMiscOpcode(10);
697 pub const wasmMiscOpcodeMemoryFill: WasmMiscOpcode = WasmMiscOpcode(11);
698 pub const wasmMiscOpcodeTableInit: WasmMiscOpcode = WasmMiscOpcode(12);
699 pub const wasmMiscOpcodeElemDrop: WasmMiscOpcode = WasmMiscOpcode(13);
700 pub const wasmMiscOpcodeTableCopy: WasmMiscOpcode = WasmMiscOpcode(14);
701 pub const wasmMiscOpcodeTableGrow: WasmMiscOpcode = WasmMiscOpcode(15);
702 pub const wasmMiscOpcodeTableSize: WasmMiscOpcode = WasmMiscOpcode(16);
703 pub const wasmMiscOpcodeTableFill: WasmMiscOpcode = WasmMiscOpcode(17);
704}
705impl WasmThreadsOpcode {
706 pub const wasmThreadsOpcodeMemoryAtomicNotify: WasmThreadsOpcode = WasmThreadsOpcode(0);
707 pub const wasmThreadsOpcodeMemoryAtomicWait32: WasmThreadsOpcode = WasmThreadsOpcode(1);
708 pub const wasmThreadsOpcodeMemoryAtomicWait64: WasmThreadsOpcode = WasmThreadsOpcode(2);
709 pub const wasmThreadsOpcodeAtomicFence: WasmThreadsOpcode = WasmThreadsOpcode(3);
710 pub const wasmThreadsOpcodeI32AtomicLoad: WasmThreadsOpcode = WasmThreadsOpcode(16);
711 pub const wasmThreadsOpcodeI64AtomicLoad: WasmThreadsOpcode = WasmThreadsOpcode(17);
712 pub const wasmThreadsOpcodeI32AtomicLoad8U: WasmThreadsOpcode = WasmThreadsOpcode(18);
713 pub const wasmThreadsOpcodeI32AtomicLoad16U: WasmThreadsOpcode = WasmThreadsOpcode(19);
714 pub const wasmThreadsOpcodeI64AtomicLoad8U: WasmThreadsOpcode = WasmThreadsOpcode(20);
715 pub const wasmThreadsOpcodeI64AtomicLoad16U: WasmThreadsOpcode = WasmThreadsOpcode(21);
716 pub const wasmThreadsOpcodeI64AtomicLoad32U: WasmThreadsOpcode = WasmThreadsOpcode(22);
717 pub const wasmThreadsOpcodeI32AtomicStore: WasmThreadsOpcode = WasmThreadsOpcode(23);
718 pub const wasmThreadsOpcodeI64AtomicStore: WasmThreadsOpcode = WasmThreadsOpcode(24);
719 pub const wasmThreadsOpcodeI32AtomicStore8: WasmThreadsOpcode = WasmThreadsOpcode(25);
720 pub const wasmThreadsOpcodeI32AtomicStore16: WasmThreadsOpcode = WasmThreadsOpcode(26);
721 pub const wasmThreadsOpcodeI64AtomicStore8: WasmThreadsOpcode = WasmThreadsOpcode(27);
722 pub const wasmThreadsOpcodeI64AtomicStore16: WasmThreadsOpcode = WasmThreadsOpcode(28);
723 pub const wasmThreadsOpcodeI64AtomicStore32: WasmThreadsOpcode = WasmThreadsOpcode(29);
724 pub const wasmThreadsOpcodeI32AtomicRMWAdd: WasmThreadsOpcode = WasmThreadsOpcode(30);
725 pub const wasmThreadsOpcodeI64AtomicRMWAdd: WasmThreadsOpcode = WasmThreadsOpcode(31);
726 pub const wasmThreadsOpcodeI32AtomicRMW8AddU: WasmThreadsOpcode = WasmThreadsOpcode(32);
727 pub const wasmThreadsOpcodeI32AtomicRMW16AddU: WasmThreadsOpcode = WasmThreadsOpcode(33);
728 pub const wasmThreadsOpcodeI64AtomicRMW8AddU: WasmThreadsOpcode = WasmThreadsOpcode(34);
729 pub const wasmThreadsOpcodeI64AtomicRMW16AddU: WasmThreadsOpcode = WasmThreadsOpcode(35);
730 pub const wasmThreadsOpcodeI64AtomicRMW32AddU: WasmThreadsOpcode = WasmThreadsOpcode(36);
731 pub const wasmThreadsOpcodeI32AtomicRMWSub: WasmThreadsOpcode = WasmThreadsOpcode(37);
732 pub const wasmThreadsOpcodeI64AtomicRMWSub: WasmThreadsOpcode = WasmThreadsOpcode(38);
733 pub const wasmThreadsOpcodeI32AtomicRMW8SubU: WasmThreadsOpcode = WasmThreadsOpcode(39);
734 pub const wasmThreadsOpcodeI32AtomicRMW16SubU: WasmThreadsOpcode = WasmThreadsOpcode(40);
735 pub const wasmThreadsOpcodeI64AtomicRMW8SubU: WasmThreadsOpcode = WasmThreadsOpcode(41);
736 pub const wasmThreadsOpcodeI64AtomicRMW16SubU: WasmThreadsOpcode = WasmThreadsOpcode(42);
737 pub const wasmThreadsOpcodeI64AtomicRMW32SubU: WasmThreadsOpcode = WasmThreadsOpcode(43);
738 pub const wasmThreadsOpcodeI32AtomicRMWAnd: WasmThreadsOpcode = WasmThreadsOpcode(44);
739 pub const wasmThreadsOpcodeI64AtomicRMWAnd: WasmThreadsOpcode = WasmThreadsOpcode(45);
740 pub const wasmThreadsOpcodeI32AtomicRMW8AndU: WasmThreadsOpcode = WasmThreadsOpcode(46);
741 pub const wasmThreadsOpcodeI32AtomicRMW16AndU: WasmThreadsOpcode = WasmThreadsOpcode(47);
742 pub const wasmThreadsOpcodeI64AtomicRMW8AndU: WasmThreadsOpcode = WasmThreadsOpcode(48);
743 pub const wasmThreadsOpcodeI64AtomicRMW16AndU: WasmThreadsOpcode = WasmThreadsOpcode(49);
744 pub const wasmThreadsOpcodeI64AtomicRMW32AndU: WasmThreadsOpcode = WasmThreadsOpcode(50);
745 pub const wasmThreadsOpcodeI32AtomicRMWOr: WasmThreadsOpcode = WasmThreadsOpcode(51);
746 pub const wasmThreadsOpcodeI64AtomicRMWOr: WasmThreadsOpcode = WasmThreadsOpcode(52);
747 pub const wasmThreadsOpcodeI32AtomicRMW8OrU: WasmThreadsOpcode = WasmThreadsOpcode(53);
748 pub const wasmThreadsOpcodeI32AtomicRMW16OrU: WasmThreadsOpcode = WasmThreadsOpcode(54);
749 pub const wasmThreadsOpcodeI64AtomicRMW8OrU: WasmThreadsOpcode = WasmThreadsOpcode(55);
750 pub const wasmThreadsOpcodeI64AtomicRMW16OrU: WasmThreadsOpcode = WasmThreadsOpcode(56);
751 pub const wasmThreadsOpcodeI64AtomicRMW32OrU: WasmThreadsOpcode = WasmThreadsOpcode(57);
752 pub const wasmThreadsOpcodeI32AtomicRMWXor: WasmThreadsOpcode = WasmThreadsOpcode(58);
753 pub const wasmThreadsOpcodeI64AtomicRMWXor: WasmThreadsOpcode = WasmThreadsOpcode(59);
754 pub const wasmThreadsOpcodeI32AtomicRMW8XorU: WasmThreadsOpcode = WasmThreadsOpcode(60);
755 pub const wasmThreadsOpcodeI32AtomicRMW16XorU: WasmThreadsOpcode = WasmThreadsOpcode(61);
756 pub const wasmThreadsOpcodeI64AtomicRMW8XorU: WasmThreadsOpcode = WasmThreadsOpcode(62);
757 pub const wasmThreadsOpcodeI64AtomicRMW16XorU: WasmThreadsOpcode = WasmThreadsOpcode(63);
758 pub const wasmThreadsOpcodeI64AtomicRMW32XorU: WasmThreadsOpcode = WasmThreadsOpcode(64);
759 pub const wasmThreadsOpcodeI32AtomicRMWXchg: WasmThreadsOpcode = WasmThreadsOpcode(65);
760 pub const wasmThreadsOpcodeI64AtomicRMWXchg: WasmThreadsOpcode = WasmThreadsOpcode(66);
761 pub const wasmThreadsOpcodeI32AtomicRMW8XchgU: WasmThreadsOpcode = WasmThreadsOpcode(67);
762 pub const wasmThreadsOpcodeI32AtomicRMW16XchgU: WasmThreadsOpcode = WasmThreadsOpcode(68);
763 pub const wasmThreadsOpcodeI64AtomicRMW8XchgU: WasmThreadsOpcode = WasmThreadsOpcode(69);
764 pub const wasmThreadsOpcodeI64AtomicRMW16XchgU: WasmThreadsOpcode = WasmThreadsOpcode(70);
765 pub const wasmThreadsOpcodeI64AtomicRMW32XchgU: WasmThreadsOpcode = WasmThreadsOpcode(71);
766 pub const wasmThreadsOpcodeI32AtomicRMWCmpxchg: WasmThreadsOpcode = WasmThreadsOpcode(72);
767 pub const wasmThreadsOpcodeI64AtomicRMWCmpxchg: WasmThreadsOpcode = WasmThreadsOpcode(73);
768 pub const wasmThreadsOpcodeI32AtomicRMW8CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(74);
769 pub const wasmThreadsOpcodeI32AtomicRMW16CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(75);
770 pub const wasmThreadsOpcodeI64AtomicRMW8CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(76);
771 pub const wasmThreadsOpcodeI64AtomicRMW16CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(77);
772 pub const wasmThreadsOpcodeI64AtomicRMW32CmpxchgU: WasmThreadsOpcode = WasmThreadsOpcode(78);
773}
774impl WasmModuleReaderErrorCode {
775 pub const wasmModuleReaderInvalidMagic: WasmModuleReaderErrorCode =
776 WasmModuleReaderErrorCode(0);
777 pub const wasmModuleReaderAllocationFailed: WasmModuleReaderErrorCode =
778 WasmModuleReaderErrorCode(1);
779 pub const wasmModuleReaderInvalidSectionID: WasmModuleReaderErrorCode =
780 WasmModuleReaderErrorCode(2);
781 pub const wasmModuleReaderInvalidSectionSize: WasmModuleReaderErrorCode =
782 WasmModuleReaderErrorCode(3);
783 pub const wasmModuleReaderIncorrectSectionRead: WasmModuleReaderErrorCode =
784 WasmModuleReaderErrorCode(4);
785 pub const wasmModuleReaderInvalidCustomSectionName: WasmModuleReaderErrorCode =
786 WasmModuleReaderErrorCode(5);
787 pub const wasmModuleReaderDebugSectionAppendFailed: WasmModuleReaderErrorCode =
788 WasmModuleReaderErrorCode(6);
789 pub const wasmModuleReaderInvalidTypeSectionTypeCount: WasmModuleReaderErrorCode =
790 WasmModuleReaderErrorCode(7);
791 pub const wasmModuleReaderInvalidFunctionTypeIndicator: WasmModuleReaderErrorCode =
792 WasmModuleReaderErrorCode(8);
793 pub const wasmModuleReaderInvalidFunctionTypeParameterCount: WasmModuleReaderErrorCode =
794 WasmModuleReaderErrorCode(9);
795 pub const wasmModuleReaderInvalidFunctionTypeResultCount: WasmModuleReaderErrorCode =
796 WasmModuleReaderErrorCode(10);
797 pub const wasmModuleReaderInvalidImportSectionImportCount: WasmModuleReaderErrorCode =
798 WasmModuleReaderErrorCode(11);
799 pub const wasmModuleReaderInvalidImportSectionImportModule: WasmModuleReaderErrorCode =
800 WasmModuleReaderErrorCode(12);
801 pub const wasmModuleReaderInvalidImportSectionImportName: WasmModuleReaderErrorCode =
802 WasmModuleReaderErrorCode(13);
803 pub const wasmModuleReaderInvalidImportSectionImportKind: WasmModuleReaderErrorCode =
804 WasmModuleReaderErrorCode(14);
805 pub const wasmModuleReaderInvalidImportSectionFunctionTypeIndex: WasmModuleReaderErrorCode =
806 WasmModuleReaderErrorCode(15);
807 pub const wasmModuleReaderInvalidValueType: WasmModuleReaderErrorCode =
808 WasmModuleReaderErrorCode(16);
809 pub const wasmModuleReaderInvalidFunctionSectionFunctionCount: WasmModuleReaderErrorCode =
810 WasmModuleReaderErrorCode(17);
811 pub const wasmModuleReaderInvalidFunctionTypeIndex: WasmModuleReaderErrorCode =
812 WasmModuleReaderErrorCode(18);
813 pub const wasmModuleReaderInvalidCodeSectionFunctionCount: WasmModuleReaderErrorCode =
814 WasmModuleReaderErrorCode(19);
815 pub const wasmModuleReaderInvalidCodeSectionCodeSize: WasmModuleReaderErrorCode =
816 WasmModuleReaderErrorCode(20);
817 pub const wasmModuleReaderInvalidCodeSectionLocalsDeclarations: WasmModuleReaderErrorCode =
818 WasmModuleReaderErrorCode(21);
819 pub const wasmModuleReaderInvalidExportSectionExportCount: WasmModuleReaderErrorCode =
820 WasmModuleReaderErrorCode(22);
821 pub const wasmModuleReaderInvalidExportSectionExportName: WasmModuleReaderErrorCode =
822 WasmModuleReaderErrorCode(23);
823 pub const wasmModuleReaderInvalidExportSectionExportKind: WasmModuleReaderErrorCode =
824 WasmModuleReaderErrorCode(24);
825 pub const wasmModuleReaderInvalidExportSectionExportIndex: WasmModuleReaderErrorCode =
826 WasmModuleReaderErrorCode(25);
827 pub const wasmModuleReaderInvalidGlobalSectionGlobalCount: WasmModuleReaderErrorCode =
828 WasmModuleReaderErrorCode(26);
829 pub const wasmModuleReaderInvalidGlobalSectionMutabilityIndicator: WasmModuleReaderErrorCode =
830 WasmModuleReaderErrorCode(27);
831 pub const wasmModuleReaderInvalidGlobalSectionInitExpression: WasmModuleReaderErrorCode =
832 WasmModuleReaderErrorCode(28);
833 pub const wasmModuleReaderInvalidMemorySectionMemoryCount: WasmModuleReaderErrorCode =
834 WasmModuleReaderErrorCode(29);
835 pub const wasmModuleReaderInvalidLimitKind: WasmModuleReaderErrorCode =
836 WasmModuleReaderErrorCode(30);
837 pub const wasmModuleReaderInvalidLimitMinimum: WasmModuleReaderErrorCode =
838 WasmModuleReaderErrorCode(31);
839 pub const wasmModuleReaderInvalidLimitMaximum: WasmModuleReaderErrorCode =
840 WasmModuleReaderErrorCode(32);
841 pub const wasmModuleReaderInvalidDataSectionDataSegmentCount: WasmModuleReaderErrorCode =
842 WasmModuleReaderErrorCode(33);
843 pub const wasmModuleReaderInvalidDataSectionKind: WasmModuleReaderErrorCode =
844 WasmModuleReaderErrorCode(34);
845 pub const wasmModuleReaderInvalidDataSectionMemoryIndex: WasmModuleReaderErrorCode =
846 WasmModuleReaderErrorCode(35);
847 pub const wasmModuleReaderInvalidDataSectionOffsetExpression: WasmModuleReaderErrorCode =
848 WasmModuleReaderErrorCode(36);
849 pub const wasmModuleReaderInvalidDataSectionBytes: WasmModuleReaderErrorCode =
850 WasmModuleReaderErrorCode(37);
851 pub const wasmModuleReaderInvalidDataCountSectionDataCount: WasmModuleReaderErrorCode =
852 WasmModuleReaderErrorCode(38);
853 pub const wasmModuleReaderInvalidTableSectionTableCount: WasmModuleReaderErrorCode =
854 WasmModuleReaderErrorCode(39);
855 pub const wasmModuleReaderInvalidTableSectionTableType: WasmModuleReaderErrorCode =
856 WasmModuleReaderErrorCode(40);
857 pub const wasmModuleReaderInvalidElementSectionElementSegmentCount: WasmModuleReaderErrorCode =
858 WasmModuleReaderErrorCode(41);
859 pub const wasmModuleReaderInvalidElementSectionTableIndex: WasmModuleReaderErrorCode =
860 WasmModuleReaderErrorCode(42);
861 pub const wasmModuleReaderInvalidElementSectionOffsetExpression: WasmModuleReaderErrorCode =
862 WasmModuleReaderErrorCode(43);
863 pub const wasmModuleReaderInvalidElementSectionFunctionIndexCount: WasmModuleReaderErrorCode =
864 WasmModuleReaderErrorCode(44);
865 pub const wasmModuleReaderInvalidElementSectionFunctionIndex: WasmModuleReaderErrorCode =
866 WasmModuleReaderErrorCode(45);
867 pub const wasmModuleReaderInvalidStartSectionFunctionIndex: WasmModuleReaderErrorCode =
868 WasmModuleReaderErrorCode(46);
869 pub const wasmModuleReaderInvalidNameSectionFunctionNameCount: WasmModuleReaderErrorCode =
870 WasmModuleReaderErrorCode(47);
871 pub const wasmModuleReaderInvalidNameSectionFunctionIndex: WasmModuleReaderErrorCode =
872 WasmModuleReaderErrorCode(48);
873 pub const wasmModuleReaderInvalidNameSectionFunctionName: WasmModuleReaderErrorCode =
874 WasmModuleReaderErrorCode(49);
875}
876impl WasmSectionID {
877 pub const wasmSectionIDCustom: WasmSectionID = WasmSectionID(0);
878 pub const wasmSectionIDType: WasmSectionID = WasmSectionID(1);
879 pub const wasmSectionIDImport: WasmSectionID = WasmSectionID(2);
880 pub const wasmSectionIDFunction: WasmSectionID = WasmSectionID(3);
881 pub const wasmSectionIDTable: WasmSectionID = WasmSectionID(4);
882 pub const wasmSectionIDMemory: WasmSectionID = WasmSectionID(5);
883 pub const wasmSectionIDGlobal: WasmSectionID = WasmSectionID(6);
884 pub const wasmSectionIDExport: WasmSectionID = WasmSectionID(7);
885 pub const wasmSectionIDStart: WasmSectionID = WasmSectionID(8);
886 pub const wasmSectionIDElement: WasmSectionID = WasmSectionID(9);
887 pub const wasmSectionIDCode: WasmSectionID = WasmSectionID(10);
888 pub const wasmSectionIDData: WasmSectionID = WasmSectionID(11);
889 pub const wasmSectionIDDataCount: WasmSectionID = WasmSectionID(12);
890}
891impl WasmNameSubsectionID {
892 pub const wasmNameSubsectionIDModuleName: WasmNameSubsectionID = WasmNameSubsectionID(0);
893 pub const wasmNameSubsectionIDFunctionNames: WasmNameSubsectionID = WasmNameSubsectionID(1);
894 pub const wasmNameSubsectionIDLocalNames: WasmNameSubsectionID = WasmNameSubsectionID(2);
895 pub const wasmNameSubsectionIDLabelNames: WasmNameSubsectionID = WasmNameSubsectionID(3);
896 pub const wasmNameSubsectionIDTypeNames: WasmNameSubsectionID = WasmNameSubsectionID(4);
897 pub const wasmNameSubsectionIDTableNames: WasmNameSubsectionID = WasmNameSubsectionID(5);
898 pub const wasmNameSubsectionIDMemoryNames: WasmNameSubsectionID = WasmNameSubsectionID(6);
899 pub const wasmNameSubsectionIDGlobalNames: WasmNameSubsectionID = WasmNameSubsectionID(7);
900 pub const wasmNameSubsectionIDElemSegmentNames: WasmNameSubsectionID = WasmNameSubsectionID(8);
901 pub const wasmNameSubsectionIDDataSegmentNames: WasmNameSubsectionID = WasmNameSubsectionID(9);
902}
903unsafe extern "C" {
904 #[link_name = "wasmMemoryAllocate__extern"]
905 pub fn wasmMemoryAllocate(initialPages: U32, maxPages: U32, shared: bool) -> *mut wasmMemory;
906 #[link_name = "wasmMemoryFree__extern"]
907 pub fn wasmMemoryFree(memory: *mut wasmMemory);
908 #[link_name = "wasmMemoryGrow__extern"]
909 pub fn wasmMemoryGrow(memory: *mut wasmMemory, delta: U32) -> U32;
910 #[link_name = "wasmMemoryCopy__extern"]
911 pub fn wasmMemoryCopy(
912 destinationMemory: *const wasmMemory,
913 sourceMemory: *const wasmMemory,
914 destinationAddress: U32,
915 sourceAddress: U32,
916 count: U32,
917 );
918 #[link_name = "wasmMemoryFill__extern"]
919 pub fn wasmMemoryFill(
920 memory: *const wasmMemory,
921 destinationAddress: U32,
922 value: U32,
923 count: U32,
924 );
925 #[link_name = "wasmTableAllocate__extern"]
926 pub fn wasmTableAllocate(table: *mut wasmTable, size: U32, maxSize: U32);
927 #[link_name = "wasmTableFree__extern"]
928 pub fn wasmTableFree(table: *mut wasmTable);
929 pub fn wasmMemoryAtomicWait(
930 mem: *mut wasmMemory,
931 address: U32,
932 expect: U64,
933 timeout: I64,
934 wait64: bool,
935 ) -> U32;
936 pub fn wasmMemoryAtomicNotify(mem: *mut wasmMemory, address: U32, count: U32) -> U32;
937 pub fn arrayEnsureCapacitySlowPath(
938 items: *mut *mut ::core::ffi::c_void,
939 length: usize,
940 capacity: *mut usize,
941 itemSize: usize,
942 ) -> bool;
943 #[link_name = "arrayEnsureCapacity__extern"]
944 pub fn arrayEnsureCapacity(
945 items: *mut *mut ::core::ffi::c_void,
946 length: usize,
947 capacity: *mut usize,
948 itemSize: usize,
949 ) -> bool;
950 #[link_name = "bufferSkipUnchecked__extern"]
951 pub fn bufferSkipUnchecked(buffer: *mut Buffer, length: usize);
952 #[link_name = "bufferReadEqual__extern"]
953 pub fn bufferReadEqual(buffer: *mut Buffer, data: *const U8, length: usize) -> bool;
954 #[link_name = "bufferReadByte__extern"]
955 pub fn bufferReadByte(buffer: *mut Buffer, result: *mut U8) -> bool;
956 #[link_name = "bufferReadF32__extern"]
957 pub fn bufferReadF32(buffer: *mut Buffer, result: *mut I32) -> bool;
958 #[link_name = "bufferReadF64__extern"]
959 pub fn bufferReadF64(buffer: *mut Buffer, result: *mut I64) -> bool;
960 #[link_name = "bufferAtEnd__extern"]
961 pub fn bufferAtEnd(buffer: *const Buffer) -> bool;
962 #[link_name = "bufferSkip__extern"]
963 pub fn bufferSkip(buffer: *mut Buffer, length: usize);
964 pub fn wasmValueTypeDescription(valueType: WasmValueType) -> *const ::core::ffi::c_char;
965 #[link_name = "wasmDecodeValueType__extern"]
966 pub fn wasmDecodeValueType(encodedValueType: I32, result: *mut WasmValueType) -> bool;
967 #[link_name = "wasmReadValueType__extern"]
968 pub fn wasmReadValueType(buffer: *mut Buffer, result: *mut WasmValueType) -> bool;
969 #[link_name = "wasmReadBlockType__extern"]
970 pub fn wasmReadBlockType(buffer: *mut Buffer, result: *mut *mut WasmValueType) -> bool;
971 pub static wasmEmptyFunctionType: WasmFunctionType;
972 #[link_name = "wasmLocalsDeclarationsGetType__extern"]
973 pub fn wasmLocalsDeclarationsGetType(
974 localsDeclarations: WasmLocalsDeclarations,
975 localIndex: U32,
976 result: *mut WasmValueType,
977 ) -> bool;
978 pub static wasmEmptyFunction: WasmFunction;
979 #[link_name = "wasmFunctionIDsEnsureCapacity__extern"]
980 pub fn wasmFunctionIDsEnsureCapacity(
981 wasmFunctionIDs: *mut WasmFunctionIDs,
982 length: usize,
983 ) -> bool;
984 #[link_name = "wasmFunctionIDsAppend__extern"]
985 pub fn wasmFunctionIDsAppend(
986 wasmFunctionIDs: *mut WasmFunctionIDs,
987 functionID: WasmFunctionID,
988 ) -> bool;
989 #[link_name = "wasmFunctionIDsFree__extern"]
990 pub fn wasmFunctionIDsFree(wasmFunctionIDs: *mut WasmFunctionIDs);
991 pub fn wasmExportKindDescription(exportKind: WasmExportKind) -> *const ::core::ffi::c_char;
992 pub static wasmEmptyExport: WasmExport;
993 pub static wasmEmptyGlobal: WasmGlobal;
994 pub static wasmEmptyFunctionImport: WasmFunctionImport;
995 #[link_name = "wasmFunctionImportsEnsureCapacity__extern"]
996 pub fn wasmFunctionImportsEnsureCapacity(
997 wasmFunctionImports: *mut WasmFunctionImports,
998 length: usize,
999 ) -> bool;
1000 #[link_name = "wasmFunctionImportsAppend__extern"]
1001 pub fn wasmFunctionImportsAppend(
1002 wasmFunctionImports: *mut WasmFunctionImports,
1003 import: WasmFunctionImport,
1004 ) -> bool;
1005 #[link_name = "wasmFunctionImportsFree__extern"]
1006 pub fn wasmFunctionImportsFree(wasmFunctionImports: *mut WasmFunctionImports);
1007 pub static wasmEmptyGlobalImport: WasmGlobalImport;
1008 #[link_name = "wasmGlobalImportsEnsureCapacity__extern"]
1009 pub fn wasmGlobalImportsEnsureCapacity(
1010 wasmGlobalImports: *mut WasmGlobalImports,
1011 length: usize,
1012 ) -> bool;
1013 #[link_name = "wasmGlobalImportsAppend__extern"]
1014 pub fn wasmGlobalImportsAppend(
1015 wasmGlobalImports: *mut WasmGlobalImports,
1016 import: WasmGlobalImport,
1017 ) -> bool;
1018 #[link_name = "wasmGlobalImportsFree__extern"]
1019 pub fn wasmGlobalImportsFree(wasmGlobalImports: *mut WasmGlobalImports);
1020 pub static wasmEmptyMemoryImport: WasmMemoryImport;
1021 #[link_name = "wasmMemoryImportsEnsureCapacity__extern"]
1022 pub fn wasmMemoryImportsEnsureCapacity(
1023 wasmMemoryImports: *mut WasmMemoryImports,
1024 length: usize,
1025 ) -> bool;
1026 #[link_name = "wasmMemoryImportsAppend__extern"]
1027 pub fn wasmMemoryImportsAppend(
1028 wasmMemoryImports: *mut WasmMemoryImports,
1029 import: WasmMemoryImport,
1030 ) -> bool;
1031 #[link_name = "wasmMemoryImportsFree__extern"]
1032 pub fn wasmMemoryImportsFree(wasmMemoryImports: *mut WasmMemoryImports);
1033 pub static wasmEmptyTableImport: WasmTableImport;
1034 #[link_name = "wasmTableImportsEnsureCapacity__extern"]
1035 pub fn wasmTableImportsEnsureCapacity(
1036 wasmTableImports: *mut WasmTableImports,
1037 length: usize,
1038 ) -> bool;
1039 #[link_name = "wasmTableImportsAppend__extern"]
1040 pub fn wasmTableImportsAppend(
1041 wasmTableImports: *mut WasmTableImports,
1042 import: WasmTableImport,
1043 ) -> bool;
1044 #[link_name = "wasmTableImportsFree__extern"]
1045 pub fn wasmTableImportsFree(wasmTableImports: *mut WasmTableImports);
1046 pub static wasmEmptyMemory: WasmMemory;
1047 pub static wasmEmptyDataSegment: WasmDataSegment;
1048 pub static wasmEmptyTable: WasmTable;
1049 pub static wasmEmptyElementSegment: WasmElementSegment;
1050 #[link_name = "wasmDebugSectionsEnsureCapacity__extern"]
1051 pub fn wasmDebugSectionsEnsureCapacity(
1052 wasmDebugSections: *mut WasmDebugSections,
1053 length: usize,
1054 ) -> bool;
1055 #[link_name = "wasmDebugSectionsAppend__extern"]
1056 pub fn wasmDebugSectionsAppend(
1057 wasmDebugSections: *mut WasmDebugSections,
1058 debugSection: WasmDebugSection,
1059 ) -> bool;
1060 #[link_name = "wasmDebugSectionsFree__extern"]
1061 pub fn wasmDebugSectionsFree(wasmDebugSections: *mut WasmDebugSections);
1062 #[link_name = "wasmDebugLinesEnsureCapacity__extern"]
1063 pub fn wasmDebugLinesEnsureCapacity(wasmDebugLines: *mut WasmDebugLines, length: usize)
1064 -> bool;
1065 #[link_name = "wasmDebugLinesAppend__extern"]
1066 pub fn wasmDebugLinesAppend(
1067 wasmDebugLines: *mut WasmDebugLines,
1068 debugLine: WasmDebugLine,
1069 ) -> bool;
1070 #[link_name = "wasmDebugLinesFree__extern"]
1071 pub fn wasmDebugLinesFree(wasmDebugLines: *mut WasmDebugLines);
1072 pub fn wasmParseDebugInfo(sections: WasmDebugSections) -> WasmDebugLines;
1073 #[link_name = "wasmNamesEnsureCapacity__extern"]
1074 pub fn wasmNamesEnsureCapacity(wasmNames: *mut WasmNames, length: usize) -> bool;
1075 #[link_name = "wasmNamesAppend__extern"]
1076 pub fn wasmNamesAppend(wasmNames: *mut WasmNames, name: *mut ::core::ffi::c_char) -> bool;
1077 #[link_name = "wasmNamesFree__extern"]
1078 pub fn wasmNamesFree(wasmNames: *mut WasmNames);
1079 #[link_name = "wasmModuleFunctionGetLocalType__extern"]
1080 pub fn wasmModuleFunctionGetLocalType(
1081 module: *const WasmModule,
1082 function: WasmFunction,
1083 localIndex: U32,
1084 result: *mut WasmValueType,
1085 ) -> bool;
1086 #[link_name = "wasmModuleGetGlobalType__extern"]
1087 pub fn wasmModuleGetGlobalType(
1088 module: *const WasmModule,
1089 globalIndex: U32,
1090 result: *mut WasmValueType,
1091 ) -> bool;
1092 #[link_name = "wasmModuleGetFunctionType__extern"]
1093 pub fn wasmModuleGetFunctionType(
1094 module: *const WasmModule,
1095 functionIndex: U32,
1096 result: *mut WasmFunctionType,
1097 ) -> bool;
1098 pub fn wasmCWriteModule(
1099 module: *const WasmModule,
1100 moduleName: *const ::core::ffi::c_char,
1101 options: WasmCWriteModuleOptions,
1102 staticFunctionIDs: WasmFunctionIDs,
1103 dynamicFunctionIDs: WasmFunctionIDs,
1104 ) -> bool;
1105 pub fn readFile(path: *const ::core::ffi::c_char) -> Buffer;
1106 pub fn wasmOpcodeDescription(opcode: WasmOpcode) -> *const ::core::ffi::c_char;
1107 pub fn wasmMiscOpcodeDescription(miscOpcode: WasmMiscOpcode) -> *const ::core::ffi::c_char;
1108 pub fn wasmThreadsOpcodeDescription(
1109 threadsOpcode: WasmThreadsOpcode,
1110 ) -> *const ::core::ffi::c_char;
1111 pub fn wasmOpcodeResultType(opcode: WasmOpcode) -> WasmValueType;
1112 pub fn wasmOpcodeParameter1Type(opcode: WasmOpcode) -> WasmValueType;
1113 #[link_name = "wasmOpcodeRead__extern"]
1114 pub fn wasmOpcodeRead(buffer: *mut Buffer, result: *mut WasmOpcode) -> bool;
1115 pub fn wasmLocalInstructionRead(buffer: *mut Buffer, result: *mut WasmLocalInstruction)
1116 -> bool;
1117 pub fn wasmGlobalInstructionRead(
1118 buffer: *mut Buffer,
1119 result: *mut WasmGlobalInstruction,
1120 ) -> bool;
1121 pub fn wasmConstInstructionRead(
1122 buffer: *mut Buffer,
1123 opcode: WasmOpcode,
1124 result: *mut WasmConstInstruction,
1125 ) -> bool;
1126 pub fn wasmMemoryArgumentInstructionRead(
1127 buffer: *mut Buffer,
1128 result: *mut WasmMemoryArgumentInstruction,
1129 ) -> bool;
1130 #[link_name = "wasmMemoryArgument8InstructionRead__extern"]
1131 pub fn wasmMemoryArgument8InstructionRead(
1132 buffer: *mut Buffer,
1133 result: *mut WasmMemoryArgumentInstruction,
1134 ) -> bool;
1135 #[link_name = "wasmMemoryArgument16InstructionRead__extern"]
1136 pub fn wasmMemoryArgument16InstructionRead(
1137 buffer: *mut Buffer,
1138 result: *mut WasmMemoryArgumentInstruction,
1139 ) -> bool;
1140 #[link_name = "wasmMemoryArgument32InstructionRead__extern"]
1141 pub fn wasmMemoryArgument32InstructionRead(
1142 buffer: *mut Buffer,
1143 result: *mut WasmMemoryArgumentInstruction,
1144 ) -> bool;
1145 #[link_name = "wasmMemoryArgument64InstructionRead__extern"]
1146 pub fn wasmMemoryArgument64InstructionRead(
1147 buffer: *mut Buffer,
1148 result: *mut WasmMemoryArgumentInstruction,
1149 ) -> bool;
1150 pub fn wasmCallInstructionRead(buffer: *mut Buffer, result: *mut WasmCallInstruction) -> bool;
1151 pub fn wasmCallIndirectInstructionRead(
1152 buffer: *mut Buffer,
1153 result: *mut WasmCallIndirectInstruction,
1154 ) -> bool;
1155 pub fn wasmBranchInstructionRead(
1156 buffer: *mut Buffer,
1157 result: *mut WasmBranchInstruction,
1158 ) -> bool;
1159 pub fn wasmBranchTableInstructionFree(instruction: WasmBranchTableInstruction);
1160 pub fn wasmBranchTableInstructionRead(
1161 buffer: *mut Buffer,
1162 result: *mut WasmBranchTableInstruction,
1163 ) -> bool;
1164 pub fn wasmMemoryInstructionRead(
1165 buffer: *mut Buffer,
1166 result: *mut WasmMemoryInstruction,
1167 ) -> bool;
1168 pub fn wasmMemoryCopyInstructionRead(
1169 buffer: *mut Buffer,
1170 result: *mut WasmMemoryCopyInstruction,
1171 ) -> bool;
1172 pub fn wasmMemoryInitInstructionRead(
1173 buffer: *mut Buffer,
1174 result: *mut WasmMemoryInitInstruction,
1175 ) -> bool;
1176 pub static wasmEmptyLabel: WasmLabel;
1177 #[link_name = "wasmLabelsEnsureCapacity__extern"]
1178 pub fn wasmLabelsEnsureCapacity(wasmLabels: *mut WasmLabels, length: usize) -> bool;
1179 #[link_name = "wasmLabelsAppend__extern"]
1180 pub fn wasmLabelsAppend(wasmLabels: *mut WasmLabels, label: WasmLabel) -> bool;
1181 #[link_name = "wasmLabelsFree__extern"]
1182 pub fn wasmLabelsFree(wasmLabels: *mut WasmLabels);
1183 pub static wasmEmptyLabelStack: WasmLabelStack;
1184 #[link_name = "wasmLabelStackClear__extern"]
1185 pub fn wasmLabelStackClear(labelStack: *mut WasmLabelStack);
1186 #[link_name = "wasmLabelStackPush__extern"]
1187 pub fn wasmLabelStackPush(
1188 labelStack: *mut WasmLabelStack,
1189 typeStackLength: usize,
1190 type_: *mut WasmValueType,
1191 result: *mut WasmLabel,
1192 ) -> bool;
1193 #[link_name = "wasmLabelStackPop__extern"]
1194 pub fn wasmLabelStackPop(labelStack: *mut WasmLabelStack);
1195 #[link_name = "wasmLabelStackGetTopIndex__extern"]
1196 pub fn wasmLabelStackGetTopIndex(labelStack: *const WasmLabelStack, index: U32) -> U32;
1197 pub fn wasmModuleReaderErrorMessage(
1198 error: *const WasmModuleReaderError,
1199 ) -> *const ::core::ffi::c_char;
1200 pub fn wasmModuleRead(reader: *mut WasmModuleReader, error: *mut *mut WasmModuleReaderError);
1201 pub fn wasmSectionIDDescription(sectionID: WasmSectionID) -> *const ::core::ffi::c_char;
1202 pub fn wasmNameSubsectionIDDescription(
1203 subsectionID: WasmNameSubsectionID,
1204 ) -> *const ::core::ffi::c_char;
1205 pub fn stringBuilderInitialize(stringBuilder: *mut StringBuilder) -> bool;
1206 pub fn stringBuilderReset(stringBuilder: *mut StringBuilder) -> bool;
1207 pub fn stringBuilderFree(stringBuilder: *mut StringBuilder);
1208 pub fn stringBuilderAppendSized(
1209 stringBuilder: *mut StringBuilder,
1210 string: *const ::core::ffi::c_char,
1211 length: usize,
1212 ) -> bool;
1213 #[link_name = "stringBuilderAppend__extern"]
1214 pub fn stringBuilderAppend(
1215 stringBuilder: *mut StringBuilder,
1216 string: *const ::core::ffi::c_char,
1217 ) -> bool;
1218 pub fn stringBuilderAppendChar(
1219 stringBuilder: *mut StringBuilder,
1220 c: ::core::ffi::c_char,
1221 ) -> bool;
1222 pub fn stringBuilderAppendCharHex(
1223 stringBuilder: *mut StringBuilder,
1224 value: ::core::ffi::c_char,
1225 ) -> bool;
1226 pub fn stringBuilderAppendU32(stringBuilder: *mut StringBuilder, value: U32) -> bool;
1227 pub fn stringBuilderAppendI32(stringBuilder: *mut StringBuilder, value: I32) -> bool;
1228 pub fn stringBuilderAppendU64(stringBuilder: *mut StringBuilder, value: U64) -> bool;
1229 pub fn stringBuilderAppendI64(stringBuilder: *mut StringBuilder, value: I64) -> bool;
1230 pub fn stringBuilderAppendF32(stringBuilder: *mut StringBuilder, value: F32) -> bool;
1231 pub fn stringBuilderAppendF64(stringBuilder: *mut StringBuilder, value: F64) -> bool;
1232 pub fn stringBuilderAppendU32Hex(stringBuilder: *mut StringBuilder, value: U32) -> bool;
1233 pub fn stringBuilderAppendU64Hex(stringBuilder: *mut StringBuilder, value: U64) -> bool;
1234 #[link_name = "wasmTypeStackEnsureCapacity__extern"]
1235 pub fn wasmTypeStackEnsureCapacity(wasmTypeStack: *mut WasmTypeStack, length: usize) -> bool;
1236 #[link_name = "wasmTypeStackAppend__extern"]
1237 pub fn wasmTypeStackAppend(wasmTypeStack: *mut WasmTypeStack, valueType: WasmValueType)
1238 -> bool;
1239 #[link_name = "wasmTypeStackFree__extern"]
1240 pub fn wasmTypeStackFree(wasmTypeStack: *mut WasmTypeStack);
1241 pub static wasmEmptyTypeStack: WasmTypeStack;
1242 #[link_name = "wasmTypeStackDrop__extern"]
1243 pub fn wasmTypeStackDrop(typeStack: *mut WasmTypeStack, count: usize);
1244 #[link_name = "wasmTypeStackClear__extern"]
1245 pub fn wasmTypeStackClear(typeStack: *mut WasmTypeStack);
1246 #[link_name = "wasmTypeStackSet__extern"]
1247 pub fn wasmTypeStackSet(
1248 typeStack: *mut WasmTypeStack,
1249 index: U32,
1250 valueType: WasmValueType,
1251 ) -> bool;
1252 #[link_name = "wasmTypeStackIsSet__extern"]
1253 pub fn wasmTypeStackIsSet(
1254 typeStack: *const WasmTypeStack,
1255 index: U32,
1256 valueType: WasmValueType,
1257 ) -> bool;
1258 #[link_name = "wasmTypeStackGetTopIndex__extern"]
1259 pub fn wasmTypeStackGetTopIndex(typeStack: *const WasmTypeStack, index: U32) -> U32;
1260}