1use anyhow::{Context, Result};
4use clap::Parser;
5use serde::Deserialize;
6use std::{
7 fmt, fs,
8 path::{Path, PathBuf},
9 time::Duration,
10};
11use wasmtime::Config;
12
13pub mod opt;
14
15#[cfg(feature = "logging")]
16fn init_file_per_thread_logger(prefix: &'static str) {
17 file_per_thread_logger::initialize(prefix);
18 file_per_thread_logger::allow_uninitialized();
19
20 #[cfg(feature = "parallel-compilation")]
25 rayon::ThreadPoolBuilder::new()
26 .spawn_handler(move |thread| {
27 let mut b = std::thread::Builder::new();
28 if let Some(name) = thread.name() {
29 b = b.name(name.to_owned());
30 }
31 if let Some(stack_size) = thread.stack_size() {
32 b = b.stack_size(stack_size);
33 }
34 b.spawn(move || {
35 file_per_thread_logger::initialize(prefix);
36 thread.run()
37 })?;
38 Ok(())
39 })
40 .build_global()
41 .unwrap();
42}
43
44wasmtime_option_group! {
45 #[derive(PartialEq, Clone, Deserialize)]
46 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
47 pub struct OptimizeOptions {
48 #[serde(default)]
50 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
51 pub opt_level: Option<wasmtime::OptLevel>,
52
53 #[serde(default)]
55 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
56 pub regalloc_algorithm: Option<wasmtime::RegallocAlgorithm>,
57
58 pub memory_may_move: Option<bool>,
61
62 pub memory_reservation: Option<u64>,
64
65 pub memory_reservation_for_growth: Option<u64>,
67
68 pub memory_guard_size: Option<u64>,
70
71 pub guard_before_linear_memory: Option<bool>,
74
75 pub table_lazy_init: Option<bool>,
80
81 pub pooling_allocator: Option<bool>,
83
84 pub pooling_decommit_batch_size: Option<usize>,
87
88 pub pooling_memory_keep_resident: Option<usize>,
91
92 pub pooling_table_keep_resident: Option<usize>,
95
96 #[serde(default)]
99 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
100 pub pooling_memory_protection_keys: Option<wasmtime::Enabled>,
101
102 pub pooling_max_memory_protection_keys: Option<usize>,
105
106 pub memory_init_cow: Option<bool>,
109
110 pub memory_guaranteed_dense_image_size: Option<u64>,
113
114 pub pooling_total_core_instances: Option<u32>,
117
118 pub pooling_total_component_instances: Option<u32>,
121
122 pub pooling_total_memories: Option<u32>,
125
126 pub pooling_total_tables: Option<u32>,
129
130 pub pooling_total_stacks: Option<u32>,
133
134 pub pooling_max_memory_size: Option<usize>,
137
138 pub pooling_table_elements: Option<usize>,
141
142 pub pooling_max_core_instance_size: Option<usize>,
145
146 pub pooling_max_unused_warm_slots: Option<u32>,
149
150 pub pooling_async_stack_keep_resident: Option<usize>,
153
154 pub pooling_max_component_instance_size: Option<usize>,
157
158 pub pooling_max_core_instances_per_component: Option<u32>,
161
162 pub pooling_max_memories_per_component: Option<u32>,
165
166 pub pooling_max_tables_per_component: Option<u32>,
169
170 pub pooling_max_tables_per_module: Option<u32>,
172
173 pub pooling_max_memories_per_module: Option<u32>,
175
176 pub pooling_total_gc_heaps: Option<u32>,
178
179 pub signals_based_traps: Option<bool>,
181
182 pub dynamic_memory_guard_size: Option<u64>,
184
185 pub static_memory_guard_size: Option<u64>,
187
188 pub static_memory_forced: Option<bool>,
190
191 pub static_memory_maximum_size: Option<u64>,
193
194 pub dynamic_memory_reserved_for_growth: Option<u64>,
196
197 #[serde(default)]
200 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
201 pub pooling_pagemap_scan: Option<wasmtime::Enabled>,
202 }
203
204 enum Optimize {
205 ...
206 }
207}
208
209wasmtime_option_group! {
210 #[derive(PartialEq, Clone, Deserialize)]
211 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
212 pub struct CodegenOptions {
213 #[serde(default)]
218 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
219 pub compiler: Option<wasmtime::Strategy>,
220 #[serde(default)]
230 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
231 pub collector: Option<wasmtime::Collector>,
232 pub cranelift_debug_verifier: Option<bool>,
234 pub cache: Option<bool>,
236 pub cache_config: Option<String>,
238 pub parallel_compilation: Option<bool>,
240 pub pcc: Option<bool>,
242 pub native_unwind_info: Option<bool>,
245
246 pub inlining: Option<bool>,
248
249 #[prefixed = "cranelift"]
250 #[serde(default)]
251 pub cranelift: Vec<(String, Option<String>)>,
254 }
255
256 enum Codegen {
257 ...
258 }
259}
260
261wasmtime_option_group! {
262 #[derive(PartialEq, Clone, Deserialize)]
263 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
264 pub struct DebugOptions {
265 pub debug_info: Option<bool>,
267 pub guest_debug: Option<bool>,
269 pub address_map: Option<bool>,
271 pub logging: Option<bool>,
273 pub log_to_files: Option<bool>,
275 pub coredump: Option<String>,
277 }
278
279 enum Debug {
280 ...
281 }
282}
283
284wasmtime_option_group! {
285 #[derive(PartialEq, Clone, Deserialize)]
286 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
287 pub struct WasmOptions {
288 pub nan_canonicalization: Option<bool>,
290 pub fuel: Option<u64>,
298 pub epoch_interruption: Option<bool>,
301 pub max_wasm_stack: Option<usize>,
304 pub async_stack_size: Option<usize>,
310 pub async_stack_zeroing: Option<bool>,
313 pub unknown_exports_allow: Option<bool>,
315 pub unknown_imports_trap: Option<bool>,
318 pub unknown_imports_default: Option<bool>,
321 pub wmemcheck: Option<bool>,
323 pub max_memory_size: Option<usize>,
328 pub max_table_elements: Option<usize>,
330 pub max_instances: Option<usize>,
332 pub max_tables: Option<usize>,
334 pub max_memories: Option<usize>,
336 pub trap_on_grow_failure: Option<bool>,
343 pub timeout: Option<Duration>,
345 pub all_proposals: Option<bool>,
347 pub bulk_memory: Option<bool>,
349 pub multi_memory: Option<bool>,
351 pub multi_value: Option<bool>,
353 pub reference_types: Option<bool>,
355 pub simd: Option<bool>,
357 pub relaxed_simd: Option<bool>,
359 pub relaxed_simd_deterministic: Option<bool>,
368 pub tail_call: Option<bool>,
370 pub threads: Option<bool>,
372 pub shared_everything_threads: Option<bool>,
374 pub memory64: Option<bool>,
376 pub component_model: Option<bool>,
378 pub component_model_async: Option<bool>,
380 pub component_model_async_builtins: Option<bool>,
383 pub component_model_async_stackful: Option<bool>,
386 pub component_model_error_context: Option<bool>,
389 pub component_model_gc: Option<bool>,
392 pub function_references: Option<bool>,
394 pub stack_switching: Option<bool>,
396 pub gc: Option<bool>,
398 pub custom_page_sizes: Option<bool>,
400 pub wide_arithmetic: Option<bool>,
402 pub extended_const: Option<bool>,
404 pub exceptions: Option<bool>,
406 pub gc_support: Option<bool>,
408 }
409
410 enum Wasm {
411 ...
412 }
413}
414
415wasmtime_option_group! {
416 #[derive(PartialEq, Clone, Deserialize)]
417 #[serde(rename_all = "kebab-case", deny_unknown_fields)]
418 pub struct WasiOptions {
419 pub cli: Option<bool>,
421 pub cli_exit_with_code: Option<bool>,
423 pub common: Option<bool>,
425 pub nn: Option<bool>,
427 pub threads: Option<bool>,
429 pub http: Option<bool>,
431 pub http_outgoing_body_buffer_chunks: Option<usize>,
435 pub http_outgoing_body_chunk_size: Option<usize>,
438 pub config: Option<bool>,
440 pub keyvalue: Option<bool>,
442 pub listenfd: Option<bool>,
446 #[serde(default)]
449 pub tcplisten: Vec<String>,
450 pub tls: Option<bool>,
452 pub preview2: Option<bool>,
455 #[serde(skip)]
464 pub nn_graph: Vec<WasiNnGraph>,
465 pub inherit_network: Option<bool>,
468 pub allow_ip_name_lookup: Option<bool>,
470 pub tcp: Option<bool>,
472 pub udp: Option<bool>,
474 pub network_error_code: Option<bool>,
476 pub preview0: Option<bool>,
478 pub inherit_env: Option<bool>,
482 #[serde(skip)]
484 pub config_var: Vec<KeyValuePair>,
485 #[serde(skip)]
487 pub keyvalue_in_memory_data: Vec<KeyValuePair>,
488 pub p3: Option<bool>,
490 }
491
492 enum Wasi {
493 ...
494 }
495}
496
497#[derive(Debug, Clone, PartialEq)]
498pub struct WasiNnGraph {
499 pub format: String,
500 pub dir: String,
501}
502
503#[derive(Debug, Clone, PartialEq)]
504pub struct KeyValuePair {
505 pub key: String,
506 pub value: String,
507}
508
509#[derive(Parser, Clone, Deserialize)]
511#[serde(deny_unknown_fields)]
512pub struct CommonOptions {
513 #[arg(short = 'O', long = "optimize", value_name = "KEY[=VAL[,..]]")]
523 #[serde(skip)]
524 opts_raw: Vec<opt::CommaSeparated<Optimize>>,
525
526 #[arg(short = 'C', long = "codegen", value_name = "KEY[=VAL[,..]]")]
528 #[serde(skip)]
529 codegen_raw: Vec<opt::CommaSeparated<Codegen>>,
530
531 #[arg(short = 'D', long = "debug", value_name = "KEY[=VAL[,..]]")]
533 #[serde(skip)]
534 debug_raw: Vec<opt::CommaSeparated<Debug>>,
535
536 #[arg(short = 'W', long = "wasm", value_name = "KEY[=VAL[,..]]")]
539 #[serde(skip)]
540 wasm_raw: Vec<opt::CommaSeparated<Wasm>>,
541
542 #[arg(short = 'S', long = "wasi", value_name = "KEY[=VAL[,..]]")]
544 #[serde(skip)]
545 wasi_raw: Vec<opt::CommaSeparated<Wasi>>,
546
547 #[arg(skip)]
550 #[serde(skip)]
551 configured: bool,
552
553 #[arg(skip)]
554 #[serde(rename = "optimize", default)]
555 pub opts: OptimizeOptions,
556
557 #[arg(skip)]
558 #[serde(rename = "codegen", default)]
559 pub codegen: CodegenOptions,
560
561 #[arg(skip)]
562 #[serde(rename = "debug", default)]
563 pub debug: DebugOptions,
564
565 #[arg(skip)]
566 #[serde(rename = "wasm", default)]
567 pub wasm: WasmOptions,
568
569 #[arg(skip)]
570 #[serde(rename = "wasi", default)]
571 pub wasi: WasiOptions,
572
573 #[arg(long, value_name = "TARGET")]
575 #[serde(skip)]
576 pub target: Option<String>,
577
578 #[arg(long = "config", value_name = "FILE")]
585 #[serde(skip)]
586 pub config: Option<PathBuf>,
587}
588
589macro_rules! match_feature {
590 (
591 [$feat:tt : $config:expr]
592 $val:ident => $e:expr,
593 $p:pat => err,
594 ) => {
595 #[cfg(feature = $feat)]
596 {
597 if let Some($val) = $config {
598 $e;
599 }
600 }
601 #[cfg(not(feature = $feat))]
602 {
603 if let Some($p) = $config {
604 anyhow::bail!(concat!("support for ", $feat, " disabled at compile time"));
605 }
606 }
607 };
608}
609
610impl CommonOptions {
611 pub fn new() -> CommonOptions {
613 CommonOptions {
614 opts_raw: Vec::new(),
615 codegen_raw: Vec::new(),
616 debug_raw: Vec::new(),
617 wasm_raw: Vec::new(),
618 wasi_raw: Vec::new(),
619 configured: true,
620 opts: Default::default(),
621 codegen: Default::default(),
622 debug: Default::default(),
623 wasm: Default::default(),
624 wasi: Default::default(),
625 target: None,
626 config: None,
627 }
628 }
629
630 fn configure(&mut self) -> Result<()> {
631 if self.configured {
632 return Ok(());
633 }
634 self.configured = true;
635 if let Some(toml_config_path) = &self.config {
636 let toml_options = CommonOptions::from_file(toml_config_path)?;
637 self.opts = toml_options.opts;
638 self.codegen = toml_options.codegen;
639 self.debug = toml_options.debug;
640 self.wasm = toml_options.wasm;
641 self.wasi = toml_options.wasi;
642 }
643 self.opts.configure_with(&self.opts_raw);
644 self.codegen.configure_with(&self.codegen_raw);
645 self.debug.configure_with(&self.debug_raw);
646 self.wasm.configure_with(&self.wasm_raw);
647 self.wasi.configure_with(&self.wasi_raw);
648 Ok(())
649 }
650
651 pub fn init_logging(&mut self) -> Result<()> {
652 self.configure()?;
653 if self.debug.logging == Some(false) {
654 return Ok(());
655 }
656 #[cfg(feature = "logging")]
657 if self.debug.log_to_files == Some(true) {
658 let prefix = "wasmtime.dbg.";
659 init_file_per_thread_logger(prefix);
660 } else {
661 use std::io::IsTerminal;
662 use tracing_subscriber::{EnvFilter, FmtSubscriber};
663 let builder = FmtSubscriber::builder()
664 .with_writer(std::io::stderr)
665 .with_env_filter(EnvFilter::from_env("WASMTIME_LOG"))
666 .with_ansi(std::io::stderr().is_terminal());
667 if std::env::var("WASMTIME_LOG_NO_CONTEXT").is_ok_and(|value| value.eq("1")) {
668 builder
669 .with_level(false)
670 .with_target(false)
671 .without_time()
672 .init()
673 } else {
674 builder.init();
675 }
676 }
677 #[cfg(not(feature = "logging"))]
678 if self.debug.log_to_files == Some(true) || self.debug.logging == Some(true) {
679 anyhow::bail!("support for logging disabled at compile time");
680 }
681 Ok(())
682 }
683
684 pub fn config(&mut self, pooling_allocator_default: Option<bool>) -> Result<Config> {
685 self.configure()?;
686 let mut config = Config::new();
687
688 match_feature! {
689 ["cranelift" : self.codegen.compiler]
690 strategy => config.strategy(strategy),
691 _ => err,
692 }
693 match_feature! {
694 ["gc" : self.codegen.collector]
695 collector => config.collector(collector),
696 _ => err,
697 }
698 if let Some(target) = &self.target {
699 config.target(target)?;
700 }
701 match_feature! {
702 ["cranelift" : self.codegen.cranelift_debug_verifier]
703 enable => config.cranelift_debug_verifier(enable),
704 true => err,
705 }
706 if let Some(enable) = self.debug.debug_info {
707 config.debug_info(enable);
708 }
709 match_feature! {
710 ["debug" : self.debug.guest_debug]
711 enable => config.guest_debug(enable),
712 _ => err,
713 }
714 if self.debug.coredump.is_some() {
715 #[cfg(feature = "coredump")]
716 config.coredump_on_trap(true);
717 #[cfg(not(feature = "coredump"))]
718 anyhow::bail!("support for coredumps disabled at compile time");
719 }
720 match_feature! {
721 ["cranelift" : self.opts.opt_level]
722 level => config.cranelift_opt_level(level),
723 _ => err,
724 }
725 match_feature! {
726 ["cranelift": self.opts.regalloc_algorithm]
727 algo => config.cranelift_regalloc_algorithm(algo),
728 _ => err,
729 }
730 match_feature! {
731 ["cranelift" : self.wasm.nan_canonicalization]
732 enable => config.cranelift_nan_canonicalization(enable),
733 true => err,
734 }
735 match_feature! {
736 ["cranelift" : self.codegen.pcc]
737 enable => config.cranelift_pcc(enable),
738 true => err,
739 }
740
741 self.enable_wasm_features(&mut config)?;
742
743 #[cfg(feature = "cranelift")]
744 for (name, value) in self.codegen.cranelift.iter() {
745 let name = name.replace('-', "_");
746 unsafe {
747 match value {
748 Some(val) => {
749 config.cranelift_flag_set(&name, val);
750 }
751 None => {
752 config.cranelift_flag_enable(&name);
753 }
754 }
755 }
756 }
757 #[cfg(not(feature = "cranelift"))]
758 if !self.codegen.cranelift.is_empty() {
759 anyhow::bail!("support for cranelift disabled at compile time");
760 }
761
762 #[cfg(feature = "cache")]
763 if self.codegen.cache != Some(false) {
764 use wasmtime::Cache;
765 let cache = match &self.codegen.cache_config {
766 Some(path) => Cache::from_file(Some(Path::new(path)))?,
767 None => Cache::from_file(None)?,
768 };
769 config.cache(Some(cache));
770 }
771 #[cfg(not(feature = "cache"))]
772 if self.codegen.cache == Some(true) {
773 anyhow::bail!("support for caching disabled at compile time");
774 }
775
776 match_feature! {
777 ["parallel-compilation" : self.codegen.parallel_compilation]
778 enable => config.parallel_compilation(enable),
779 true => err,
780 }
781
782 let memory_reservation = self
783 .opts
784 .memory_reservation
785 .or(self.opts.static_memory_maximum_size);
786 if let Some(size) = memory_reservation {
787 config.memory_reservation(size);
788 }
789
790 if let Some(enable) = self.opts.static_memory_forced {
791 config.memory_may_move(!enable);
792 }
793 if let Some(enable) = self.opts.memory_may_move {
794 config.memory_may_move(enable);
795 }
796
797 let memory_guard_size = self
798 .opts
799 .static_memory_guard_size
800 .or(self.opts.dynamic_memory_guard_size)
801 .or(self.opts.memory_guard_size);
802 if let Some(size) = memory_guard_size {
803 config.memory_guard_size(size);
804 }
805
806 let mem_for_growth = self
807 .opts
808 .memory_reservation_for_growth
809 .or(self.opts.dynamic_memory_reserved_for_growth);
810 if let Some(size) = mem_for_growth {
811 config.memory_reservation_for_growth(size);
812 }
813 if let Some(enable) = self.opts.guard_before_linear_memory {
814 config.guard_before_linear_memory(enable);
815 }
816 if let Some(enable) = self.opts.table_lazy_init {
817 config.table_lazy_init(enable);
818 }
819
820 if self.wasm.fuel.is_some() {
822 config.consume_fuel(true);
823 }
824
825 if let Some(enable) = self.wasm.epoch_interruption {
826 config.epoch_interruption(enable);
827 }
828 if let Some(enable) = self.debug.address_map {
829 config.generate_address_map(enable);
830 }
831 if let Some(enable) = self.opts.memory_init_cow {
832 config.memory_init_cow(enable);
833 }
834 if let Some(size) = self.opts.memory_guaranteed_dense_image_size {
835 config.memory_guaranteed_dense_image_size(size);
836 }
837 if let Some(enable) = self.opts.signals_based_traps {
838 config.signals_based_traps(enable);
839 }
840 if let Some(enable) = self.codegen.native_unwind_info {
841 config.native_unwind_info(enable);
842 }
843 if let Some(enable) = self.codegen.inlining {
844 config.compiler_inlining(enable);
845 }
846
847 #[cfg(any(feature = "async", feature = "stack-switching"))]
850 {
851 if let Some(size) = self.wasm.async_stack_size {
852 config.async_stack_size(size);
853 }
854 }
855 #[cfg(not(any(feature = "async", feature = "stack-switching")))]
856 {
857 if let Some(_size) = self.wasm.async_stack_size {
858 anyhow::bail!(concat!(
859 "support for async/stack-switching disabled at compile time"
860 ));
861 }
862 }
863
864 match_feature! {
865 ["pooling-allocator" : self.opts.pooling_allocator.or(pooling_allocator_default)]
866 enable => {
867 if enable {
868 let mut cfg = wasmtime::PoolingAllocationConfig::default();
869 if let Some(size) = self.opts.pooling_memory_keep_resident {
870 cfg.linear_memory_keep_resident(size);
871 }
872 if let Some(size) = self.opts.pooling_table_keep_resident {
873 cfg.table_keep_resident(size);
874 }
875 if let Some(limit) = self.opts.pooling_total_core_instances {
876 cfg.total_core_instances(limit);
877 }
878 if let Some(limit) = self.opts.pooling_total_component_instances {
879 cfg.total_component_instances(limit);
880 }
881 if let Some(limit) = self.opts.pooling_total_memories {
882 cfg.total_memories(limit);
883 }
884 if let Some(limit) = self.opts.pooling_total_tables {
885 cfg.total_tables(limit);
886 }
887 if let Some(limit) = self.opts.pooling_table_elements
888 .or(self.wasm.max_table_elements)
889 {
890 cfg.table_elements(limit);
891 }
892 if let Some(limit) = self.opts.pooling_max_core_instance_size {
893 cfg.max_core_instance_size(limit);
894 }
895 match_feature! {
896 ["async" : self.opts.pooling_total_stacks]
897 limit => cfg.total_stacks(limit),
898 _ => err,
899 }
900 if let Some(max) = self.opts.pooling_max_memory_size
901 .or(self.wasm.max_memory_size)
902 {
903 cfg.max_memory_size(max);
904 }
905 if let Some(size) = self.opts.pooling_decommit_batch_size {
906 cfg.decommit_batch_size(size);
907 }
908 if let Some(max) = self.opts.pooling_max_unused_warm_slots {
909 cfg.max_unused_warm_slots(max);
910 }
911 match_feature! {
912 ["async" : self.opts.pooling_async_stack_keep_resident]
913 size => cfg.async_stack_keep_resident(size),
914 _ => err,
915 }
916 if let Some(max) = self.opts.pooling_max_component_instance_size {
917 cfg.max_component_instance_size(max);
918 }
919 if let Some(max) = self.opts.pooling_max_core_instances_per_component {
920 cfg.max_core_instances_per_component(max);
921 }
922 if let Some(max) = self.opts.pooling_max_memories_per_component {
923 cfg.max_memories_per_component(max);
924 }
925 if let Some(max) = self.opts.pooling_max_tables_per_component {
926 cfg.max_tables_per_component(max);
927 }
928 if let Some(max) = self.opts.pooling_max_tables_per_module {
929 cfg.max_tables_per_module(max);
930 }
931 if let Some(max) = self.opts.pooling_max_memories_per_module {
932 cfg.max_memories_per_module(max);
933 }
934 match_feature! {
935 ["memory-protection-keys" : self.opts.pooling_memory_protection_keys]
936 enable => cfg.memory_protection_keys(enable),
937 _ => err,
938 }
939 match_feature! {
940 ["memory-protection-keys" : self.opts.pooling_max_memory_protection_keys]
941 max => cfg.max_memory_protection_keys(max),
942 _ => err,
943 }
944 match_feature! {
945 ["gc" : self.opts.pooling_total_gc_heaps]
946 max => cfg.total_gc_heaps(max),
947 _ => err,
948 }
949 if let Some(enabled) = self.opts.pooling_pagemap_scan {
950 cfg.pagemap_scan(enabled);
951 }
952 config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(cfg));
953 }
954 },
955 true => err,
956 }
957
958 if self.opts.pooling_memory_protection_keys.is_some()
959 && !self.opts.pooling_allocator.unwrap_or(false)
960 {
961 anyhow::bail!("memory protection keys require the pooling allocator");
962 }
963
964 if self.opts.pooling_max_memory_protection_keys.is_some()
965 && !self.opts.pooling_memory_protection_keys.is_some()
966 {
967 anyhow::bail!(
968 "max memory protection keys requires memory protection keys to be enabled"
969 );
970 }
971
972 match_feature! {
973 ["async" : self.wasm.async_stack_zeroing]
974 enable => config.async_stack_zeroing(enable),
975 _ => err,
976 }
977
978 if let Some(max) = self.wasm.max_wasm_stack {
979 config.max_wasm_stack(max);
980
981 #[cfg(any(feature = "async", feature = "stack-switching"))]
985 if self.wasm.async_stack_size.is_none() {
986 const DEFAULT_HOST_STACK: usize = 512 << 10;
987 config.async_stack_size(max + DEFAULT_HOST_STACK);
988 }
989 }
990
991 if let Some(enable) = self.wasm.relaxed_simd_deterministic {
992 config.relaxed_simd_deterministic(enable);
993 }
994 match_feature! {
995 ["cranelift" : self.wasm.wmemcheck]
996 enable => config.wmemcheck(enable),
997 true => err,
998 }
999
1000 if let Some(enable) = self.wasm.gc_support {
1001 config.gc_support(enable);
1002 }
1003
1004 Ok(config)
1005 }
1006
1007 pub fn enable_wasm_features(&self, config: &mut Config) -> Result<()> {
1008 let all = self.wasm.all_proposals;
1009
1010 if let Some(enable) = self.wasm.simd.or(all) {
1011 config.wasm_simd(enable);
1012 }
1013 if let Some(enable) = self.wasm.relaxed_simd.or(all) {
1014 config.wasm_relaxed_simd(enable);
1015 }
1016 if let Some(enable) = self.wasm.bulk_memory.or(all) {
1017 config.wasm_bulk_memory(enable);
1018 }
1019 if let Some(enable) = self.wasm.multi_value.or(all) {
1020 config.wasm_multi_value(enable);
1021 }
1022 if let Some(enable) = self.wasm.tail_call.or(all) {
1023 config.wasm_tail_call(enable);
1024 }
1025 if let Some(enable) = self.wasm.multi_memory.or(all) {
1026 config.wasm_multi_memory(enable);
1027 }
1028 if let Some(enable) = self.wasm.memory64.or(all) {
1029 config.wasm_memory64(enable);
1030 }
1031 if let Some(enable) = self.wasm.stack_switching {
1032 config.wasm_stack_switching(enable);
1033 }
1034 if let Some(enable) = self.wasm.custom_page_sizes.or(all) {
1035 config.wasm_custom_page_sizes(enable);
1036 }
1037 if let Some(enable) = self.wasm.wide_arithmetic.or(all) {
1038 config.wasm_wide_arithmetic(enable);
1039 }
1040 if let Some(enable) = self.wasm.extended_const.or(all) {
1041 config.wasm_extended_const(enable);
1042 }
1043
1044 macro_rules! handle_conditionally_compiled {
1045 ($(($feature:tt, $field:tt, $method:tt))*) => ($(
1046 if let Some(enable) = self.wasm.$field.or(all) {
1047 #[cfg(feature = $feature)]
1048 config.$method(enable);
1049 #[cfg(not(feature = $feature))]
1050 if enable && all.is_none() {
1051 anyhow::bail!("support for {} was disabled at compile-time", $feature);
1052 }
1053 }
1054 )*)
1055 }
1056
1057 handle_conditionally_compiled! {
1058 ("component-model", component_model, wasm_component_model)
1059 ("component-model-async", component_model_async, wasm_component_model_async)
1060 ("component-model-async", component_model_async_builtins, wasm_component_model_async_builtins)
1061 ("component-model-async", component_model_async_stackful, wasm_component_model_async_stackful)
1062 ("component-model", component_model_error_context, wasm_component_model_error_context)
1063 ("threads", threads, wasm_threads)
1064 ("gc", gc, wasm_gc)
1065 ("gc", reference_types, wasm_reference_types)
1066 ("gc", function_references, wasm_function_references)
1067 ("gc", exceptions, wasm_exceptions)
1068 ("stack-switching", stack_switching, wasm_stack_switching)
1069 }
1070
1071 if let Some(enable) = self.wasm.component_model_gc {
1072 #[cfg(all(feature = "component-model", feature = "gc"))]
1073 config.wasm_component_model_gc(enable);
1074 #[cfg(not(all(feature = "component-model", feature = "gc")))]
1075 if enable && all.is_none() {
1076 anyhow::bail!("support for `component-model-gc` was disabled at compile time")
1077 }
1078 }
1079
1080 Ok(())
1081 }
1082
1083 pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
1084 let path_ref = path.as_ref();
1085 let file_contents = fs::read_to_string(path_ref)
1086 .with_context(|| format!("failed to read config file: {path_ref:?}"))?;
1087 toml::from_str::<CommonOptions>(&file_contents)
1088 .with_context(|| format!("failed to parse TOML config file {path_ref:?}"))
1089 }
1090}
1091
1092#[cfg(test)]
1093mod tests {
1094 use wasmtime::{OptLevel, RegallocAlgorithm};
1095
1096 use super::*;
1097
1098 #[test]
1099 fn from_toml() {
1100 let empty_toml = "";
1102 let mut common_options: CommonOptions = toml::from_str(empty_toml).unwrap();
1103 common_options.config(None).unwrap();
1104
1105 let basic_toml = r#"
1107 [optimize]
1108 [codegen]
1109 [debug]
1110 [wasm]
1111 [wasi]
1112 "#;
1113 let mut common_options: CommonOptions = toml::from_str(basic_toml).unwrap();
1114 common_options.config(None).unwrap();
1115
1116 for (opt_value, expected) in [
1118 ("0", Some(OptLevel::None)),
1119 ("1", Some(OptLevel::Speed)),
1120 ("2", Some(OptLevel::Speed)),
1121 ("\"s\"", Some(OptLevel::SpeedAndSize)),
1122 ("\"hello\"", None), ("3", None), ] {
1125 let toml = format!(
1126 r#"
1127 [optimize]
1128 opt-level = {opt_value}
1129 "#,
1130 );
1131 let parsed_opt_level = toml::from_str::<CommonOptions>(&toml)
1132 .ok()
1133 .and_then(|common_options| common_options.opts.opt_level);
1134
1135 assert_eq!(
1136 parsed_opt_level, expected,
1137 "Mismatch for input '{opt_value}'. Parsed: {parsed_opt_level:?}, Expected: {expected:?}"
1138 );
1139 }
1140
1141 for (regalloc_value, expected) in [
1143 ("\"backtracking\"", Some(RegallocAlgorithm::Backtracking)),
1144 ("\"single-pass\"", Some(RegallocAlgorithm::SinglePass)),
1145 ("\"hello\"", None), ("3", None), ("true", None), ] {
1149 let toml = format!(
1150 r#"
1151 [optimize]
1152 regalloc-algorithm = {regalloc_value}
1153 "#,
1154 );
1155 let parsed_regalloc_algorithm = toml::from_str::<CommonOptions>(&toml)
1156 .ok()
1157 .and_then(|common_options| common_options.opts.regalloc_algorithm);
1158 assert_eq!(
1159 parsed_regalloc_algorithm, expected,
1160 "Mismatch for input '{regalloc_value}'. Parsed: {parsed_regalloc_algorithm:?}, Expected: {expected:?}"
1161 );
1162 }
1163
1164 for (strategy_value, expected) in [
1166 ("\"cranelift\"", Some(wasmtime::Strategy::Cranelift)),
1167 ("\"winch\"", Some(wasmtime::Strategy::Winch)),
1168 ("\"hello\"", None), ("5", None), ("true", None), ] {
1172 let toml = format!(
1173 r#"
1174 [codegen]
1175 compiler = {strategy_value}
1176 "#,
1177 );
1178 let parsed_strategy = toml::from_str::<CommonOptions>(&toml)
1179 .ok()
1180 .and_then(|common_options| common_options.codegen.compiler);
1181 assert_eq!(
1182 parsed_strategy, expected,
1183 "Mismatch for input '{strategy_value}'. Parsed: {parsed_strategy:?}, Expected: {expected:?}",
1184 );
1185 }
1186
1187 for (collector_value, expected) in [
1189 (
1190 "\"drc\"",
1191 Some(wasmtime::Collector::DeferredReferenceCounting),
1192 ),
1193 ("\"null\"", Some(wasmtime::Collector::Null)),
1194 ("\"hello\"", None), ("5", None), ("true", None), ] {
1198 let toml = format!(
1199 r#"
1200 [codegen]
1201 collector = {collector_value}
1202 "#,
1203 );
1204 let parsed_collector = toml::from_str::<CommonOptions>(&toml)
1205 .ok()
1206 .and_then(|common_options| common_options.codegen.collector);
1207 assert_eq!(
1208 parsed_collector, expected,
1209 "Mismatch for input '{collector_value}'. Parsed: {parsed_collector:?}, Expected: {expected:?}",
1210 );
1211 }
1212 }
1213}
1214
1215impl Default for CommonOptions {
1216 fn default() -> CommonOptions {
1217 CommonOptions::new()
1218 }
1219}
1220
1221impl fmt::Display for CommonOptions {
1222 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1223 let CommonOptions {
1224 codegen_raw,
1225 codegen,
1226 debug_raw,
1227 debug,
1228 opts_raw,
1229 opts,
1230 wasm_raw,
1231 wasm,
1232 wasi_raw,
1233 wasi,
1234 configured,
1235 target,
1236 config,
1237 } = self;
1238 if let Some(target) = target {
1239 write!(f, "--target {target} ")?;
1240 }
1241 if let Some(config) = config {
1242 write!(f, "--config {} ", config.display())?;
1243 }
1244
1245 let codegen_flags;
1246 let opts_flags;
1247 let wasi_flags;
1248 let wasm_flags;
1249 let debug_flags;
1250
1251 if *configured {
1252 codegen_flags = codegen.to_options();
1253 debug_flags = debug.to_options();
1254 wasi_flags = wasi.to_options();
1255 wasm_flags = wasm.to_options();
1256 opts_flags = opts.to_options();
1257 } else {
1258 codegen_flags = codegen_raw
1259 .iter()
1260 .flat_map(|t| t.0.iter())
1261 .cloned()
1262 .collect();
1263 debug_flags = debug_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
1264 wasi_flags = wasi_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
1265 wasm_flags = wasm_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
1266 opts_flags = opts_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
1267 }
1268
1269 for flag in codegen_flags {
1270 write!(f, "-C{flag} ")?;
1271 }
1272 for flag in opts_flags {
1273 write!(f, "-O{flag} ")?;
1274 }
1275 for flag in wasi_flags {
1276 write!(f, "-S{flag} ")?;
1277 }
1278 for flag in wasm_flags {
1279 write!(f, "-W{flag} ")?;
1280 }
1281 for flag in debug_flags {
1282 write!(f, "-D{flag} ")?;
1283 }
1284
1285 Ok(())
1286 }
1287}