1use std::borrow::Cow;
2use std::collections::{HashMap, HashSet};
3use std::mem;
4use wasm_encoder::{
5 CodeSection, ConstExpr, CustomSection, DataSection, ElementSection, Elements, Encode,
6 EntityType, ExportKind, ExportSection, Function, FunctionSection, GlobalType, ImportSection,
7 MemoryType, Module, NameMap, NameSection, RefType, TableType, TypeSection, ValType,
8};
9use wit_parser::abi::{WasmSignature, WasmType};
10use wit_parser::{
11 Handle, LiftLowerAbi, LiveTypes, ManglingAndAbi, Resolve, ResourceIntrinsic, SizeAlign, Type,
12 TypeDefKind, TypeId, TypeOwner, WasmExport, WasmExportKind, WasmImport, WorldId, WorldItem,
13 WorldKey,
14};
15
16mod async_;
17mod bindgen;
18pub mod metadata;
19pub use crate::async_::AsyncFilterSet;
20pub use crate::metadata::Metadata;
21
22pub const C_HEADER: &'static str = include_str!("../wit_dylib.h");
23
24#[derive(Default, Clone, Debug)]
25#[cfg_attr(feature = "clap", derive(clap::Parser))]
26pub struct DylibOpts {
27 #[cfg_attr(feature = "clap", clap(long, value_name = "name"))]
30 pub interpreter: Option<String>,
31
32 #[cfg_attr(feature = "clap", clap(flatten))]
33 pub async_: AsyncFilterSet,
34
35 #[cfg_attr(
40 feature = "clap",
41 clap(long, value_name = "loc", default_value = "global")
42 )]
43 pub stack_pointer: StackPointer,
44}
45
46#[derive(Default, Clone, Debug)]
47#[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
48pub enum StackPointer {
49 #[default]
50 Global,
51 TaskContext,
52}
53
54pub fn create(resolve: &Resolve, world_id: WorldId, opts: Option<&mut DylibOpts>) -> Vec<u8> {
55 create_with_metadata(resolve, world_id, opts).0
56}
57
58pub fn create_with_metadata(
59 resolve: &Resolve,
60 world_id: WorldId,
61 mut opts: Option<&mut DylibOpts>,
62) -> (Vec<u8>, Metadata) {
63 let mut adapter = Adapter::default();
64 if let Some(opts) = &mut opts {
65 adapter.opts = opts.clone();
66 }
67 let result = adapter.encode(resolve, world_id);
68 if let Some(opts) = &mut opts {
69 **opts = adapter.opts;
70 }
71 (result, adapter.metadata)
72}
73
74#[derive(Default)]
75struct Adapter {
76 types: TypeSection,
77 wasm_type_map: HashMap<(Vec<ValType>, Vec<ValType>), u32>,
78 imports: ImportSection,
79 imports_done: bool,
80 global_index: u32,
81 table_base: Option<u32>,
82 memory_base: Option<u32>,
83 stack_pointer: Option<ImportedStackPointer>,
84 func_index: u32,
85 functions: FunctionSection,
86 exports: ExportSection,
87 code: CodeSection,
88 global_names: NameMap,
89 function_names: NameMap,
90 metadata: Metadata,
91 type_map: HashMap<TypeId, metadata::Type>,
92 resource_map: HashMap<TypeId, usize>,
93 export_resource_map: HashMap<TypeId, usize>,
94 intrinsics: Option<bindgen::WitInterpreterIntrinsics>,
95 sizes: SizeAlign,
96 opts: DylibOpts,
97
98 elem_segment: Vec<u32>,
104}
105
106#[derive(Copy, Clone)]
107enum ImportedStackPointer {
108 Global(u32),
109 TaskContext { get: u32, set: u32 },
110}
111
112#[derive(Default)]
113struct Imports<'a> {
114 wit_imports: Vec<WitImport<'a>>,
115 wit_exports: Vec<WitExport<'a>>,
116}
117
118struct WitImport<'a> {
119 interface: Option<&'a WorldKey>,
120 func: &'a wit_parser::Function,
121 import_index: u32,
122}
123
124struct WitExport<'a> {
125 interface: Option<&'a WorldKey>,
126 func: &'a wit_parser::Function,
127 async_task_return_index: Option<u32>,
128}
129
130struct PayloadData {
133 new_elem_index: u32,
135 read_elem_index: u32,
137 write_elem_index: u32,
139 cancel_read_elem_index: u32,
141 cancel_write_elem_index: u32,
143 drop_readable_elem_index: u32,
145 drop_writable_elem_index: u32,
147 ordinal: usize,
151 function: String,
154}
155
156impl Adapter {
157 pub fn encode(&mut self, resolve: &Resolve, world_id: WorldId) -> Vec<u8> {
158 self.sizes.fill(resolve);
159
160 let imports = self.add_imports(resolve, world_id);
165
166 let mut payload_data = HashMap::new();
167 self.collect_payload_data(resolve, world_id, &mut payload_data);
168
169 self.imports_done = true;
170
171 let cabi_realloc = self.intrinsics().cabi_realloc;
175 self.exports
176 .export("cabi_realloc", ExportKind::Func, cabi_realloc);
177
178 self.bindgen_world(resolve, world_id, &imports, &payload_data);
181
182 let (metadata_offset, metadata) = self.encode_metadata();
188 let mut ctor = Function::new([]);
189 ctor.instructions().i32_const(metadata_offset as i32);
190 ctor.instructions().global_get(self.memory_base());
191 ctor.instructions().i32_add();
192 ctor.instructions().call(self.intrinsics().initialize);
193 ctor.instructions().end();
194 let ty = self.define_ty([], []);
195 self.define_func("__wasm_call_ctors", ty, ctor, true);
196
197 self.finish(&metadata)
198 }
199
200 fn mangling(
201 &mut self,
202 resolve: &Resolve,
203 interface: Option<&WorldKey>,
204 func: &wit_parser::Function,
205 is_import: bool,
206 ) -> ManglingAndAbi {
207 let abi = if self
208 .opts
209 .async_
210 .is_async(resolve, interface, func, is_import)
211 {
212 LiftLowerAbi::AsyncCallback
213 } else {
214 LiftLowerAbi::Sync
215 };
216 ManglingAndAbi::Legacy(abi)
217 }
218
219 fn resource_intrinsic_mangling(&mut self) -> ManglingAndAbi {
220 ManglingAndAbi::Legacy(LiftLowerAbi::Sync)
221 }
222
223 fn collect_payload_data_for_func(
227 &mut self,
228 resolve: &Resolve,
229 interface: Option<&WorldKey>,
230 func: &wit_parser::Function,
231 prefix: &str,
232 data: &mut HashMap<TypeId, PayloadData>,
233 ) {
234 let mut make = |arg_count, kind, ordinal| {
235 let module = format!(
236 "{prefix}{}",
237 interface
238 .map(|name| resolve.name_world_key(name))
239 .unwrap_or_else(|| "$root".into())
240 );
241 let function = func.name.clone();
242
243 let import = |me: &mut Self, prefix, name, params, results| {
244 let ty = me.define_ty(params, results);
245 let import = me.import_func(
246 &module,
247 &format!("{prefix}[{kind}-{name}-{ordinal}]{function}"),
248 ty,
249 );
250 me.push_elem(import)
251 };
252
253 let new_elem_index = import(self, "", "new", vec![], vec![ValType::I64]);
254 let read_elem_index = import(
255 self,
256 "[async-lower]",
257 "read",
258 vec![ValType::I32; arg_count],
259 vec![ValType::I32],
260 );
261 let write_elem_index = import(
262 self,
263 "[async-lower]",
264 "write",
265 vec![ValType::I32; arg_count],
266 vec![ValType::I32],
267 );
268 let cancel_read_elem_index = import(
269 self,
270 "",
271 "cancel-read",
272 vec![ValType::I32],
273 vec![ValType::I32],
274 );
275 let cancel_write_elem_index = import(
276 self,
277 "",
278 "cancel-write",
279 vec![ValType::I32],
280 vec![ValType::I32],
281 );
282 let drop_readable_elem_index =
283 import(self, "", "drop-readable", vec![ValType::I32], vec![]);
284 let drop_writable_elem_index =
285 import(self, "", "drop-writable", vec![ValType::I32], vec![]);
286
287 PayloadData {
288 new_elem_index,
289 read_elem_index,
290 write_elem_index,
291 cancel_read_elem_index,
292 cancel_write_elem_index,
293 drop_readable_elem_index,
294 drop_writable_elem_index,
295 ordinal,
296 function,
297 }
298 };
299
300 for (ordinal, ty) in func
301 .find_futures_and_streams(resolve)
302 .into_iter()
303 .enumerate()
304 {
305 match &resolve.types[ty].kind {
306 TypeDefKind::Future(_) => {
307 data.entry(ty).or_insert_with(|| make(2, "future", ordinal))
308 }
309 TypeDefKind::Stream(_) => {
310 data.entry(ty).or_insert_with(|| make(3, "stream", ordinal))
311 }
312 _ => unreachable!(),
313 };
314 }
315 }
316
317 fn collect_payload_data(
318 &mut self,
319 resolve: &Resolve,
320 world_id: WorldId,
321 data: &mut HashMap<TypeId, PayloadData>,
322 ) {
323 let world = &resolve.worlds[world_id];
324
325 for (key, import) in world.imports.iter() {
326 match import {
327 WorldItem::Interface { id, .. } => {
328 for (_, func) in resolve.interfaces[*id].functions.iter() {
329 self.collect_payload_data_for_func(resolve, Some(key), func, "", data);
330 }
331 }
332 WorldItem::Type { .. } => {}
333 WorldItem::Function(func) => {
334 self.collect_payload_data_for_func(resolve, None, func, "", data);
335 }
336 }
337 }
338
339 for (key, export) in world.exports.iter() {
340 match export {
341 WorldItem::Interface { id, .. } => {
342 for (_, func) in resolve.interfaces[*id].functions.iter() {
343 self.collect_payload_data_for_func(
344 resolve,
345 Some(key),
346 func,
347 "[export]",
348 data,
349 );
350 }
351 }
352 WorldItem::Type { .. } => unreachable!(),
353 WorldItem::Function(func) => {
354 self.collect_payload_data_for_func(resolve, None, func, "[export]", data);
355 }
356 }
357 }
358 }
359
360 fn add_imports<'a>(&mut self, resolve: &'a Resolve, world_id: WorldId) -> Imports<'a> {
361 let mut ret = Imports::default();
362 let world = &resolve.worlds[world_id];
363
364 self.intrinsics = Some(bindgen::WitInterpreterIntrinsics::new(self));
367
368 for (interface, import) in world.imports.iter() {
373 match import {
374 WorldItem::Interface { id, .. } => {
375 for (_, func) in resolve.interfaces[*id].functions.iter() {
376 self.add_imported_func(resolve, Some(interface), func, &mut ret);
377 }
378 for (_, ty) in resolve.interfaces[*id].types.iter() {
379 self.add_imported_type_intrinsics(resolve, Some(interface), *ty);
380 }
381 }
382 WorldItem::Type { id, .. } => {
383 self.add_imported_type_intrinsics(resolve, None, *id);
384 }
385 WorldItem::Function(func) => {
386 self.add_imported_func(resolve, None, func, &mut ret);
387 }
388 }
389 }
390
391 for (name, export) in world.exports.iter() {
394 match export {
395 WorldItem::Function(func) => {
396 self.add_imported_func_intrinsics_for_export(resolve, None, func, &mut ret);
397 }
398 WorldItem::Interface { id: export, .. } => {
399 for (_, ty) in resolve.interfaces[*export].types.iter() {
400 self.add_imported_type_intrinsics_for_export(resolve, Some(name), *ty);
401 }
402 for (_, func) in resolve.interfaces[*export].functions.iter() {
403 self.add_imported_func_intrinsics_for_export(
404 resolve,
405 Some(name),
406 func,
407 &mut ret,
408 );
409 }
410 }
411 WorldItem::Type { .. } => unreachable!(),
412 }
413 }
414
415 let const_i32_global = GlobalType {
416 val_type: ValType::I32,
417 mutable: false,
418 shared: false,
419 };
420 let mut_i32_global = GlobalType {
421 val_type: ValType::I32,
422 mutable: true,
423 shared: false,
424 };
425
426 self.table_base = Some(self.import_global("env", "__table_base", const_i32_global));
427 self.memory_base = Some(self.import_global("env", "__memory_base", const_i32_global));
428 self.stack_pointer = Some(match self.opts.stack_pointer {
429 StackPointer::Global => ImportedStackPointer::Global(self.import_global(
430 "env",
431 "__stack_pointer",
432 mut_i32_global,
433 )),
434 StackPointer::TaskContext => {
435 let get_ty = self.define_ty([], [ValType::I32]);
436 let set_ty = self.define_ty([ValType::I32], []);
437 ImportedStackPointer::TaskContext {
438 get: self.import_func("$root", "[context-get-0]", get_ty),
439 set: self.import_func("$root", "[context-set-0]", set_ty),
440 }
441 }
442 });
443
444 self.imports.import(
445 "env",
446 "memory",
447 EntityType::Memory(MemoryType {
448 minimum: 0,
449 maximum: None,
450 memory64: false,
451 shared: false,
452 page_size_log2: None,
453 }),
454 );
455
456 self.imports.import(
457 "env",
458 "__indirect_function_table",
459 EntityType::Table(TableType {
460 element_type: RefType::FUNCREF,
461 minimum: 0,
462 maximum: None,
463 table64: false,
464 shared: false,
465 }),
466 );
467 ret
468 }
469
470 fn add_imported_func<'a>(
471 &mut self,
472 resolve: &'a Resolve,
473 interface: Option<&'a WorldKey>,
474 func: &'a wit_parser::Function,
475 imports: &mut Imports<'a>,
476 ) {
477 let mangling = self.mangling(resolve, interface, func, true);
478 let (module, name) =
479 resolve.wasm_import_name(mangling, WasmImport::Func { interface, func });
480 let sig = resolve.wasm_signature(mangling.import_variant(), func);
481 let ty = self.define_wasm_sig(sig);
482 let import_index = self.import_func(&module, &name, ty);
483 imports.wit_imports.push(WitImport {
484 func,
485 interface,
486 import_index,
487 });
488 }
489
490 fn add_imported_type_intrinsics<'a>(
491 &mut self,
492 resolve: &Resolve,
493 interface: Option<&'a WorldKey>,
494 id: TypeId,
495 ) {
496 let mangling = self.resource_intrinsic_mangling();
497 let ty = &resolve.types[id];
498 match ty.kind {
499 TypeDefKind::Resource => {
500 let (module, name) = resolve.wasm_import_name(
501 mangling,
502 WasmImport::ResourceIntrinsic {
503 interface,
504 resource: id,
505 intrinsic: ResourceIntrinsic::ImportedDrop,
506 },
507 );
508 let core_ty = self.define_ty([ValType::I32], []);
509 let drop = self.import_func(&module, &name, core_ty);
510 let drop_elem_index = self.push_elem(drop);
511 let resource_index = self.metadata.resources.len();
512 self.metadata.resources.push(metadata::Resource {
513 id,
514 interface: interface.map(|i| resolve.name_world_key(i)),
515 name: ty.name.clone().unwrap(),
516 drop_elem_index,
517 new_elem_index: None,
518 rep_elem_index: None,
519 });
520 let prev = self.resource_map.insert(id, resource_index);
521 assert!(prev.is_none());
522 }
523
524 _ => {}
527 }
528 }
529
530 fn add_imported_type_intrinsics_for_export<'a>(
531 &mut self,
532 resolve: &Resolve,
533 interface: Option<&'a WorldKey>,
534 id: TypeId,
535 ) {
536 let ty = &resolve.types[id];
537 let mangling = self.resource_intrinsic_mangling();
538 match ty.kind {
539 TypeDefKind::Resource => {
540 let drop_ty = self.define_ty([ValType::I32], []);
541 let new_rep_ty = self.define_ty([ValType::I32], [ValType::I32]);
542
543 let mut import = |ty, intrinsic| {
544 let (module, name) = resolve.wasm_import_name(
545 mangling,
546 WasmImport::ResourceIntrinsic {
547 interface,
548 resource: id,
549 intrinsic,
550 },
551 );
552 self.import_func(&module, &name, ty)
553 };
554
555 let drop = import(drop_ty, ResourceIntrinsic::ExportedDrop);
556 let new = import(new_rep_ty, ResourceIntrinsic::ExportedNew);
557 let rep = import(new_rep_ty, ResourceIntrinsic::ExportedRep);
558
559 let drop_elem_index = self.push_elem(drop);
560 let new_elem_index = Some(self.push_elem(new));
561 let rep_elem_index = Some(self.push_elem(rep));
562
563 let resource_index = self.metadata.resources.len();
564 self.metadata.resources.push(metadata::Resource {
565 id,
566 interface: interface.map(|i| resolve.name_world_key(i)),
567 name: ty.name.clone().unwrap(),
568 drop_elem_index,
569 new_elem_index,
570 rep_elem_index,
571 });
572
573 let prev = self.export_resource_map.insert(id, resource_index);
579 assert!(prev.is_none());
580 }
581
582 _ => {}
585 }
586 }
587
588 fn add_imported_func_intrinsics_for_export<'a>(
591 &mut self,
592 resolve: &Resolve,
593 interface: Option<&'a WorldKey>,
594 func: &'a wit_parser::Function,
595 ret: &mut Imports<'a>,
596 ) {
597 let mangling = self.mangling(resolve, interface, func, false);
598 let async_task_return_index = if mangling.is_async() {
599 let (module, name, sig) =
600 func.task_return_import(resolve, interface, mangling.mangling());
601 let ty = self.define_wasm_sig(sig);
602 Some(self.import_func(&module, &name, ty))
603 } else {
604 None
605 };
606 ret.wit_exports.push(WitExport {
607 interface,
608 func,
609 async_task_return_index,
610 });
611 }
612
613 fn bindgen_world(
614 &mut self,
615 resolve: &Resolve,
616 world_id: WorldId,
617 imports: &Imports<'_>,
618 payload_data: &HashMap<TypeId, PayloadData>,
619 ) {
620 let world = &resolve.worlds[world_id];
621
622 let mut import_types = LiveTypes::default();
626 let mut interface_names = HashMap::new();
627 for (interface, import) in world.imports.iter() {
628 import_types.add_world_item(resolve, import);
629 if let WorldItem::Interface { id, .. } = import {
630 interface_names.insert(*id, interface);
631 }
632 }
633 for (_, export) in world.exports.iter() {
634 match export {
635 WorldItem::Function(func) => import_types.add_func(resolve, func),
636 WorldItem::Interface { .. } => {}
637 WorldItem::Type { .. } => unreachable!(),
638 }
639 }
640 for ty in import_types.iter() {
641 let key = match resolve.types[ty].owner {
642 TypeOwner::Interface(id) => Some(interface_names[&id]),
643 _ => None,
644 };
645 self.register_type(resolve, key, ty, payload_data);
646 }
647
648 for import in imports.wit_imports.iter() {
652 self.bindgen_world_func_import(resolve, import);
653 }
654 for export in imports.wit_exports.iter().filter(|i| i.interface.is_none()) {
655 self.bindgen_world_func_export(resolve, export);
656 }
657
658 let to_keep = imported_types_used_by_exported_interfaces(resolve, world_id);
665 self.type_map.retain(|id, _| to_keep.contains(*id));
666 let mut exported_types = LiveTypes::default();
667 let mut export_names = HashMap::new();
668 for (interface, import) in world.exports.iter() {
669 if let WorldItem::Interface { id, .. } = import {
670 exported_types.add_world_item(resolve, import);
671 export_names.insert(*id, interface);
672 }
673 }
674 for (ty, index) in mem::take(&mut self.export_resource_map) {
675 self.resource_map.insert(ty, index);
676 }
677 for ty in exported_types.iter() {
678 if self.type_map.contains_key(&ty) {
679 continue;
680 }
681 let key = match resolve.types[ty].owner {
682 TypeOwner::Interface(id) => Some(export_names[&id]),
683 _ => None,
684 };
685 self.register_type(resolve, key, ty, payload_data);
686
687 if let Some(index) = self.resource_map.get(&ty) {
688 self.bindgen_world_export_resource_dtor(resolve, key.unwrap(), ty, *index);
689 }
690 }
691
692 for export in imports.wit_exports.iter().filter(|i| i.interface.is_some()) {
695 self.bindgen_world_func_export(resolve, export);
696 }
697 }
698
699 fn register_type(
705 &mut self,
706 resolve: &Resolve,
707 key: Option<&WorldKey>,
708 id: TypeId,
709 payload_data: &HashMap<TypeId, PayloadData>,
710 ) {
711 let ty = &resolve.types[id];
712 let interface = key.map(|key| resolve.name_world_key(key));
713 let name = ty.name.clone();
714 let result = match &ty.kind {
715 TypeDefKind::Record(r) => {
716 let index = self.metadata.records.len();
717 let fields = r
718 .fields
719 .iter()
720 .map(|field| (field.name.clone(), self.lookup_ty(&field.ty)))
721 .collect();
722 self.metadata.records.push(metadata::Record {
723 id,
724 interface,
725 name: name.unwrap(),
726 fields,
727 });
728 metadata::Type::Record(index)
729 }
730 TypeDefKind::Flags(t) => {
731 let index = self.metadata.flags.len();
732 let names = t.flags.iter().map(|f| f.name.clone()).collect();
733 self.metadata.flags.push(metadata::Flags {
734 id,
735 interface,
736 name: name.unwrap(),
737 names,
738 });
739 metadata::Type::Flags(index)
740 }
741 TypeDefKind::Tuple(t) => {
742 let index = self.metadata.tuples.len();
743 let types = t.types.iter().map(|t| self.lookup_ty(t)).collect();
744 self.metadata.tuples.push(metadata::Tuple {
745 id,
746 interface,
747 name,
748 types,
749 });
750 metadata::Type::Tuple(index)
751 }
752 TypeDefKind::Variant(t) => {
753 let index = self.metadata.variants.len();
754 let cases = t
755 .cases
756 .iter()
757 .map(|c| (c.name.clone(), c.ty.map(|t| self.lookup_ty(&t))))
758 .collect();
759 self.metadata.variants.push(metadata::Variant {
760 id,
761 interface,
762 name: name.unwrap(),
763 cases,
764 });
765 metadata::Type::Variant(index)
766 }
767 TypeDefKind::Enum(t) => {
768 let index = self.metadata.enums.len();
769 let names = t.cases.iter().map(|f| f.name.clone()).collect();
770 self.metadata.enums.push(metadata::Enum {
771 id,
772 interface,
773 name: name.unwrap(),
774 names,
775 });
776 metadata::Type::Enum(index)
777 }
778 TypeDefKind::Option(t) => {
779 let index = self.metadata.options.len();
780 self.metadata.options.push(metadata::WitOption {
781 id,
782 interface,
783 name,
784 ty: self.lookup_ty(t),
785 });
786 metadata::Type::Option(index)
787 }
788 TypeDefKind::Result(t) => {
789 let index = self.metadata.results.len();
790 self.metadata.results.push(metadata::WitResult {
791 id,
792 interface,
793 name,
794 ok: t.ok.map(|t| self.lookup_ty(&t)),
795 err: t.err.map(|t| self.lookup_ty(&t)),
796 });
797 metadata::Type::Result(index)
798 }
799 TypeDefKind::List(t) => {
800 let index = self.metadata.lists.len();
801 self.metadata.lists.push(metadata::List {
802 id,
803 interface,
804 name,
805 ty: self.lookup_ty(t),
806 });
807 metadata::Type::List(index)
808 }
809 TypeDefKind::FixedLengthList(t, len) => {
810 let index = self.metadata.fixed_length_lists.len();
811 self.metadata
812 .fixed_length_lists
813 .push(metadata::FixedLengthList {
814 id,
815 interface,
816 name,
817 len: *len,
818 ty: self.lookup_ty(t),
819 });
820 metadata::Type::FixedLengthList(index)
821 }
822 TypeDefKind::Future(t) => {
823 let index = self.metadata.futures.len();
824
825 let Some(&PayloadData {
826 new_elem_index,
827 read_elem_index,
828 write_elem_index,
829 cancel_read_elem_index,
830 cancel_write_elem_index,
831 drop_readable_elem_index,
832 drop_writable_elem_index,
833 ordinal,
834 ref function,
835 }) = payload_data.get(&id)
836 else {
837 panic!("encountered future type not used in any function")
839 };
840
841 let lift_elem_index = t.map(|t| {
845 let ty = self.define_ty([ValType::I32; 2], []);
846 let func = bindgen::lift_payload(self, resolve, t);
847 let func = self.define_func(
848 &format!("[future-lift-{ordinal}]{function}"),
849 ty,
850 func,
851 false,
852 );
853 self.push_elem(func)
854 });
855
856 let lower_elem_index = t.map(|t| {
857 let ty = self.define_ty([ValType::I32; 2], []);
858 let func = bindgen::lower_payload(self, resolve, t);
859 let func = self.define_func(
860 &format!("[future-lower-{ordinal}]{function}"),
861 ty,
862 func,
863 false,
864 );
865 self.push_elem(func)
866 });
867
868 self.metadata.futures.push(metadata::Future {
869 id,
870 interface,
871 name,
872 ty: t.map(|t| self.lookup_ty(&t)),
873 new_elem_index,
874 read_elem_index,
875 write_elem_index,
876 cancel_read_elem_index,
877 cancel_write_elem_index,
878 drop_readable_elem_index,
879 drop_writable_elem_index,
880 lift_elem_index,
881 lower_elem_index,
882 abi_payload_size: t.map(|t| self.sizes.size(&t).size_wasm32()).unwrap_or(0),
883 abi_payload_align: t.map(|t| self.sizes.align(&t).align_wasm32()).unwrap_or(1),
884 });
885 metadata::Type::Future(index)
886 }
887 TypeDefKind::Stream(t) => {
888 let index = self.metadata.streams.len();
889
890 let Some(&PayloadData {
891 new_elem_index,
892 read_elem_index,
893 write_elem_index,
894 cancel_read_elem_index,
895 cancel_write_elem_index,
896 drop_readable_elem_index,
897 drop_writable_elem_index,
898 ordinal,
899 ref function,
900 }) = payload_data.get(&id)
901 else {
902 panic!("encountered stream type not used in any function")
904 };
905
906 let lift_elem_index = t.map(|t| {
917 let ty = self.define_ty([ValType::I32; 2], []);
918 let func = bindgen::lift_payload(self, resolve, t);
919 let func = self.define_func(
920 &format!("[stream-lift-{ordinal}]{function}"),
921 ty,
922 func,
923 false,
924 );
925 self.push_elem(func)
926 });
927
928 let lower_elem_index = t.map(|t| {
929 let ty = self.define_ty([ValType::I32; 2], []);
930 let func = bindgen::lower_payload(self, resolve, t);
931 let func = self.define_func(
932 &format!("[stream-lower-{ordinal}]{function}"),
933 ty,
934 func,
935 false,
936 );
937 self.push_elem(func)
938 });
939
940 self.metadata.streams.push(metadata::Stream {
941 id,
942 interface,
943 name,
944 ty: t.map(|t| self.lookup_ty(&t)),
945 new_elem_index,
946 read_elem_index,
947 write_elem_index,
948 cancel_read_elem_index,
949 cancel_write_elem_index,
950 drop_readable_elem_index,
951 drop_writable_elem_index,
952 lift_elem_index,
953 lower_elem_index,
954 abi_payload_size: t.map(|t| self.sizes.size(&t).size_wasm32()).unwrap_or(0),
955 abi_payload_align: t.map(|t| self.sizes.align(&t).align_wasm32()).unwrap_or(1),
956 });
957 metadata::Type::Stream(index)
958 }
959 TypeDefKind::Type(t) => {
960 let index = self.metadata.aliases.len();
961 self.metadata.aliases.push(metadata::Alias {
962 id,
963 interface,
964 name: name.unwrap(),
965 ty: self.lookup_ty(t),
966 });
967 metadata::Type::Alias(index)
968 }
969 TypeDefKind::Resource => metadata::Type::Own(self.resource_map[&id]),
970
971 TypeDefKind::Handle(Handle::Own(t)) => {
974 metadata::Type::Own(self.resource_map[&dealias(resolve, *t)])
975 }
976 TypeDefKind::Handle(Handle::Borrow(t)) => {
977 metadata::Type::Borrow(self.resource_map[&dealias(resolve, *t)])
978 }
979 TypeDefKind::Map(k, v) => {
980 let index = self.metadata.maps.len();
981 self.metadata.maps.push(metadata::Map {
982 id,
983 interface,
984 name,
985 key_type: self.lookup_ty(k),
986 value_type: self.lookup_ty(v),
987 });
988 metadata::Type::Map(index)
989 }
990 TypeDefKind::Unknown => unreachable!(),
991 };
992 self.type_map.insert(id, result);
993 }
994
995 fn lookup_ty(&self, ty: &Type) -> metadata::Type {
996 match ty {
997 Type::U8 => metadata::Type::U8,
998 Type::U16 => metadata::Type::U16,
999 Type::U32 => metadata::Type::U32,
1000 Type::U64 => metadata::Type::U64,
1001 Type::S8 => metadata::Type::S8,
1002 Type::S16 => metadata::Type::S16,
1003 Type::S32 => metadata::Type::S32,
1004 Type::S64 => metadata::Type::S64,
1005 Type::F32 => metadata::Type::F32,
1006 Type::F64 => metadata::Type::F64,
1007 Type::Bool => metadata::Type::Bool,
1008 Type::Char => metadata::Type::Char,
1009 Type::String => metadata::Type::String,
1010 Type::ErrorContext => metadata::Type::ErrorContext,
1011 Type::Id(id) => self.type_map[id],
1015 }
1016 }
1017
1018 fn bindgen_world_func_import(&mut self, resolve: &Resolve, import: &WitImport<'_>) {
1019 let func = import.func;
1020 let mangling = self.mangling(resolve, import.interface, func, true);
1021 let body = bindgen::import(
1022 self,
1023 resolve,
1024 func,
1025 mangling.import_variant(),
1026 import.import_index,
1027 );
1028
1029 let ty = if mangling.is_async() {
1030 self.define_ty([ValType::I32; 2], [ValType::I32])
1032 } else {
1033 self.define_ty([ValType::I32], [])
1035 };
1036
1037 let idx = self.define_func(&format!("adapter {}", func.name), ty, body, false);
1038 let elem_index = self.push_elem(idx);
1039
1040 let sync_import_elem_index;
1041 let async_import_elem_index;
1042 let async_import_lift_results_elem_index;
1043
1044 if mangling.is_async() {
1045 sync_import_elem_index = None;
1046 async_import_elem_index = Some(elem_index);
1047 let body =
1048 bindgen::lift_async_import_results(self, resolve, func, mangling.import_variant());
1049 let ty = self.define_ty([ValType::I32; 2], []);
1050 let idx = self.define_func(&format!("lift results {}", func.name), ty, body, false);
1051 async_import_lift_results_elem_index = Some(self.push_elem(idx));
1052 } else {
1053 sync_import_elem_index = Some(elem_index);
1054 async_import_elem_index = None;
1055 async_import_lift_results_elem_index = None;
1056 }
1057
1058 self.metadata.import_funcs.push(metadata::ImportFunc {
1059 interface: import.interface.map(|k| resolve.name_world_key(k)),
1060 name: func.name.clone(),
1061 sync_import_elem_index,
1062 async_import_elem_index,
1063 async_import_lift_results_elem_index,
1064 args: func.params.iter().map(|p| self.lookup_ty(&p.ty)).collect(),
1065 result: func.result.map(|t| self.lookup_ty(&t)),
1066 async_abi_area: self.async_import_abi_area(resolve, mangling, func),
1067 })
1068 }
1069
1070 fn async_import_abi_area(
1073 &self,
1074 resolve: &Resolve,
1075 mangling: ManglingAndAbi,
1076 func: &wit_parser::Function,
1077 ) -> Option<(usize, usize)> {
1078 if !mangling.is_async() {
1079 return None;
1080 }
1081
1082 let info = self
1083 .sizes
1084 .record(bindgen::async_import_abi_area_types(resolve, func));
1085 Some((info.size.size_wasm32(), info.align.align_wasm32()))
1086 }
1087
1088 fn bindgen_world_func_export(&mut self, resolve: &Resolve, export: &WitExport<'_>) {
1089 let func = export.func;
1090 let mangling = self.mangling(resolve, export.interface, func, false);
1091 let sig = resolve.wasm_signature(mangling.export_variant(), func);
1092 let ty = self.define_wasm_sig(sig);
1093 let name = resolve.wasm_export_name(
1094 mangling,
1095 WasmExport::Func {
1096 interface: export.interface,
1097 func,
1098 kind: WasmExportKind::Normal,
1099 },
1100 );
1101
1102 let metadata_func_index = self.metadata.export_funcs.len();
1103 let body = bindgen::export(
1104 self,
1105 resolve,
1106 func,
1107 mangling.export_variant(),
1108 metadata_func_index,
1109 );
1110 self.define_func(&name, ty, body, true);
1111
1112 let mut async_export_task_return_elem_index = None;
1113 match mangling {
1114 ManglingAndAbi::Standard32 | ManglingAndAbi::Legacy(LiftLowerAbi::Sync) => {
1118 let post_return_name = resolve.wasm_export_name(
1119 mangling,
1120 WasmExport::Func {
1121 interface: export.interface,
1122 func,
1123 kind: WasmExportKind::PostReturn,
1124 },
1125 );
1126 let post_return = bindgen::post_return(
1127 self,
1128 resolve,
1129 func,
1130 mangling.export_variant(),
1131 metadata_func_index,
1132 );
1133 let mut sig = resolve.wasm_signature(mangling.export_variant(), func);
1134 sig.params = mem::take(&mut sig.results);
1135 let post_return_ty = self.define_wasm_sig(sig);
1136 self.define_func(&post_return_name, post_return_ty, post_return, true);
1137 }
1138
1139 ManglingAndAbi::Legacy(LiftLowerAbi::AsyncCallback) => {
1146 let callback_name = resolve.wasm_export_name(
1147 mangling,
1148 WasmExport::Func {
1149 interface: export.interface,
1150 func,
1151 kind: WasmExportKind::Callback,
1152 },
1153 );
1154 let mut callback = Function::new([]);
1159 let mut ins = callback.instructions();
1160 ins.local_get(0);
1161 ins.local_get(1);
1162 ins.local_get(2);
1163 ins.i32_const(metadata_func_index.try_into().unwrap());
1164 let export_async_callback = self.intrinsics().export_async_callback;
1165 ins.call(export_async_callback);
1166 ins.end();
1167 let callback_ty = self.define_ty([ValType::I32; 3], [ValType::I32]);
1168 self.define_func(&callback_name, callback_ty, callback, true);
1169
1170 let task_return = bindgen::task_return(
1171 self,
1172 resolve,
1173 func,
1174 mangling.export_variant(),
1175 export.async_task_return_index.unwrap(),
1176 );
1177 let task_return_ty = self.define_ty([ValType::I32], []);
1178 let task_return = self.define_func(
1179 &format!("task.return {}", func.name),
1180 task_return_ty,
1181 task_return,
1182 false,
1183 );
1184 async_export_task_return_elem_index = Some(self.push_elem(task_return));
1185 }
1186
1187 ManglingAndAbi::Legacy(LiftLowerAbi::AsyncStackful) => unimplemented!(),
1188 }
1189
1190 self.metadata.export_funcs.push(metadata::ExportFunc {
1191 interface: export.interface.map(|k| resolve.name_world_key(k)),
1192 name: func.name.clone(),
1193 async_export_task_return_elem_index,
1194 args: func.params.iter().map(|p| self.lookup_ty(&p.ty)).collect(),
1195 result: func.result.map(|t| self.lookup_ty(&t)),
1196 })
1197 }
1198
1199 fn bindgen_world_export_resource_dtor(
1200 &mut self,
1201 resolve: &Resolve,
1202 interface: &WorldKey,
1203 resource: TypeId,
1204 index: usize,
1205 ) {
1206 let mangling = self.resource_intrinsic_mangling();
1207 let name = resolve.wasm_export_name(
1208 mangling,
1209 WasmExport::ResourceDtor {
1210 interface,
1211 resource,
1212 },
1213 );
1214 let dtor = self.intrinsics().resource_dtor;
1215 let mut func = Function::new([]);
1216 let mut ins = func.instructions();
1217 ins.i32_const(index.try_into().unwrap());
1218 ins.local_get(0);
1219 ins.call(dtor);
1220 ins.end();
1221 let ty = self.define_ty([ValType::I32], []);
1222 self.define_func(&name, ty, func, true);
1223 }
1224
1225 fn encode_metadata(&mut self) -> (u32, Vec<u8>) {
1226 let (metadata_offset, metadata, apply_relocs) =
1227 self.metadata.encode(self.table_base(), self.memory_base());
1228 if let Some(apply_relocs) = apply_relocs {
1229 let ty = self.define_ty([], []);
1230 self.define_func("__wasm_apply_data_relocs", ty, apply_relocs, true);
1231 }
1232 (metadata_offset, metadata)
1233 }
1234
1235 fn table_base(&self) -> u32 {
1236 self.table_base.unwrap()
1237 }
1238
1239 fn intrinsics(&self) -> &bindgen::WitInterpreterIntrinsics {
1240 self.intrinsics.as_ref().unwrap()
1241 }
1242
1243 fn memory_base(&self) -> u32 {
1244 self.memory_base.unwrap()
1245 }
1246
1247 fn push_elem(&mut self, elem: u32) -> u32 {
1248 let ret = self.elem_segment.len();
1249 self.elem_segment.push(elem);
1250 u32::try_from(ret).unwrap()
1251 }
1252
1253 fn finish(&mut self, metadata: &[u8]) -> Vec<u8> {
1254 let mut elements = ElementSection::new();
1256 if !self.elem_segment.is_empty() {
1257 elements.active(
1258 Some(0),
1259 &ConstExpr::global_get(self.table_base()),
1260 Elements::Functions(Cow::Borrowed(&self.elem_segment)),
1261 );
1262 }
1263
1264 let mut data = DataSection::new();
1266 data.active(
1267 0,
1268 &ConstExpr::global_get(self.memory_base()),
1269 metadata.iter().copied(),
1270 );
1271
1272 let mut names = NameSection::new();
1273 names.functions(&self.function_names);
1274 names.globals(&self.global_names);
1275
1276 let dylink0 = {
1277 struct MemInfo {
1278 memory_size: u32,
1279 memory_alignment: u32,
1280 table_size: u32,
1281 table_alignment: u32,
1282 }
1283
1284 let mem_info = MemInfo {
1285 memory_size: metadata.len().try_into().unwrap(),
1286 memory_alignment: 2,
1287 table_size: self.elem_segment.len().try_into().unwrap(),
1288 table_alignment: 0,
1289 };
1290
1291 let mut mem_info_subsection = Vec::new();
1292 mem_info.memory_size.encode(&mut mem_info_subsection);
1293 mem_info.memory_alignment.encode(&mut mem_info_subsection);
1294 mem_info.table_size.encode(&mut mem_info_subsection);
1295 mem_info.table_alignment.encode(&mut mem_info_subsection);
1296
1297 let mut needed_subsection = Vec::new();
1298 if let Some(name) = &self.opts.interpreter {
1299 [name.as_str()].encode(&mut needed_subsection);
1300 }
1301
1302 const WASM_DYLINK_MEM_INFO: u8 = 1;
1303 const WASM_DYLINK_NEEDED: u8 = 2;
1304
1305 let mut dylink0 = Vec::new();
1306 dylink0.push(WASM_DYLINK_MEM_INFO);
1307 mem_info_subsection.encode(&mut dylink0);
1308 if self.opts.interpreter.is_some() {
1309 dylink0.push(WASM_DYLINK_NEEDED);
1310 needed_subsection.encode(&mut dylink0);
1311 }
1312 dylink0
1313 };
1314
1315 let mut result = Module::new();
1316 result.section(&CustomSection {
1317 name: Cow::Borrowed("dylink.0"),
1318 data: Cow::Borrowed(&dylink0),
1319 });
1320 result.section(&self.types);
1321 result.section(&self.imports);
1322 result.section(&self.functions);
1323 result.section(&self.exports);
1324 if !elements.is_empty() {
1325 result.section(&elements);
1326 }
1327 result.section(&self.code);
1328 result.section(&data);
1329 result.section(&names);
1330
1331 result.finish()
1332 }
1333
1334 fn define_wasm_sig(&mut self, sig: WasmSignature) -> u32 {
1335 let ret = self.define_ty(
1336 sig.params
1337 .iter()
1338 .map(|t| self.map_wasm_type(*t))
1339 .collect::<Vec<_>>(),
1340 sig.results
1341 .iter()
1342 .map(|t| self.map_wasm_type(*t))
1343 .collect::<Vec<_>>(),
1344 );
1345 return ret;
1346 }
1347
1348 fn map_wasm_type(&self, a: WasmType) -> ValType {
1349 match a {
1350 WasmType::I32 => ValType::I32,
1351 WasmType::I64 => ValType::I64,
1352 WasmType::F32 => ValType::F32,
1353 WasmType::F64 => ValType::F64,
1354 WasmType::PointerOrI64 => ValType::I64,
1355 WasmType::Length | WasmType::Pointer => ValType::I32,
1356 }
1357 }
1358
1359 fn import_global(&mut self, module: &str, name: &str, ty: GlobalType) -> u32 {
1360 assert!(!self.imports_done);
1361 self.imports.import(module, name, ty);
1362 let ret = self.global_index;
1363 self.global_index += 1;
1364 self.global_names.append(ret, name);
1365 ret
1366 }
1367
1368 fn import_func(&mut self, module: &str, name: &str, ty: u32) -> u32 {
1369 assert!(!self.imports_done);
1370 self.imports.import(module, name, EntityType::Function(ty));
1371 let ret = self.func_index;
1372 self.func_index += 1;
1373 self.function_names.append(ret, name);
1374 ret
1375 }
1376
1377 fn define_func(&mut self, name: &str, ty: u32, body: Function, export: bool) -> u32 {
1378 assert!(self.imports_done);
1379 let ret = self.func_index;
1380 self.func_index += 1;
1381 self.functions.function(ty);
1382 self.code.function(&body);
1383 self.function_names.append(ret, name);
1384 if export {
1385 self.exports.export(name, ExportKind::Func, ret);
1386 }
1387 ret
1388 }
1389
1390 fn define_ty<P, R>(&mut self, params: P, results: R) -> u32
1391 where
1392 P: IntoIterator<Item = ValType> + Clone,
1393 P::IntoIter: ExactSizeIterator,
1394 R: IntoIterator<Item = ValType> + Clone,
1395 R::IntoIter: ExactSizeIterator,
1396 {
1397 let param_vec = params.clone().into_iter().collect::<Vec<_>>();
1398 let result_vec = results.clone().into_iter().collect::<Vec<_>>();
1399 *self
1400 .wasm_type_map
1401 .entry((param_vec, result_vec))
1402 .or_insert_with(|| {
1403 let ret = self.types.len();
1404 self.types.ty().function(params, results);
1405 ret
1406 })
1407 }
1408}
1409
1410fn imported_types_used_by_exported_interfaces(resolve: &Resolve, world: WorldId) -> LiveTypes {
1411 let mut live_export_types = LiveTypes::default();
1414 let mut exported_interfaces = HashSet::new();
1415 for (_, export) in resolve.worlds[world].exports.iter() {
1416 match export {
1417 WorldItem::Function(_) => {}
1418 WorldItem::Interface { id, .. } => {
1419 exported_interfaces.insert(*id);
1420 live_export_types.add_interface(resolve, *id)
1421 }
1422 WorldItem::Type { .. } => unreachable!(),
1423 }
1424 }
1425
1426 let mut live_import_types = LiveTypes::default();
1430 for ty in live_export_types.iter() {
1431 if let TypeOwner::Interface(id) = resolve.types[ty].owner {
1432 if !exported_interfaces.contains(&id) {
1433 live_import_types.add_interface(resolve, id);
1434 }
1435 }
1436 }
1437
1438 live_import_types
1439}
1440
1441fn dealias(resolve: &Resolve, mut id: TypeId) -> TypeId {
1442 loop {
1443 match resolve.types[id].kind {
1444 TypeDefKind::Type(Type::Id(other)) => id = other,
1445 _ => break id,
1446 }
1447 }
1448}
1449
1450#[cfg(test)]
1451mod tests {
1452 use wasmparser::{Operator, Parser, Payload};
1453 use wit_parser::Resolve;
1454
1455 #[derive(Copy, Clone)]
1456 enum Which {
1457 S8,
1458 S16,
1459 }
1460
1461 #[test]
1462 fn s8_uses_signed_load() {
1463 assert!(find_signed_load(Which::S8));
1464 }
1465
1466 #[test]
1467 fn s16_uses_signed_load() {
1468 assert!(find_signed_load(Which::S16));
1469 }
1470
1471 fn find_signed_load(which: Which) -> bool {
1472 let mut resolve = Resolve::default();
1473 let ty = match which {
1474 Which::S8 => "s8",
1475 Which::S16 => "s16",
1476 };
1477 let package = resolve
1478 .push_str(
1479 "wit",
1480 &format!(
1481 "package test:test;
1482world w {{
1483 export foo: func(v: list<{ty}>);
1484}}
1485"
1486 ),
1487 )
1488 .unwrap();
1489 let world = resolve.select_world(&[package], None).unwrap();
1490 let adapter = super::create(&resolve, world, None);
1491 for payload in Parser::new(0).parse_all(&adapter) {
1492 match payload.unwrap() {
1493 Payload::CodeSectionEntry(body) => {
1494 for operator in body.get_operators_reader().unwrap() {
1495 match (operator.unwrap(), which) {
1496 (Operator::I32Load16S { .. }, Which::S16)
1497 | (Operator::I32Load8S { .. }, Which::S8) => return true,
1498 _ => {}
1499 }
1500 }
1501 }
1502 _ => {}
1503 }
1504 }
1505 false
1506 }
1507}