1 //! Contains the common Wasmtime command line interface (CLI) flags. 2 3 use anyhow::{Context, Result}; 4 use clap::Parser; 5 use serde::Deserialize; 6 use std::{ 7 fmt, fs, 8 path::{Path, PathBuf}, 9 time::Duration, 10 }; 11 use wasmtime::Config; 12 13 pub mod opt; 14 15 #[cfg(feature = "logging")] 16 fn init_file_per_thread_logger(prefix: &'static str) { 17 file_per_thread_logger::initialize(prefix); 18 file_per_thread_logger::allow_uninitialized(); 19 20 // Extending behavior of default spawner: 21 // https://docs.rs/rayon/1.1.0/rayon/struct.ThreadPoolBuilder.html#method.spawn_handler 22 // Source code says DefaultSpawner is implementation detail and 23 // shouldn't be used directly. 24 #[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 44 wasmtime_option_group! { 45 #[derive(PartialEq, Clone, Deserialize)] 46 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 47 pub struct OptimizeOptions { 48 /// Optimization level of generated code (0-2, s; default: 2) 49 #[serde(default)] 50 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")] 51 pub opt_level: Option<wasmtime::OptLevel>, 52 53 /// Register allocator algorithm choice. 54 #[serde(default)] 55 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")] 56 pub regalloc_algorithm: Option<wasmtime::RegallocAlgorithm>, 57 58 /// Do not allow Wasm linear memories to move in the host process's 59 /// address space. 60 pub memory_may_move: Option<bool>, 61 62 /// Initial virtual memory allocation size for memories. 63 pub memory_reservation: Option<u64>, 64 65 /// Bytes to reserve at the end of linear memory for growth into. 66 pub memory_reservation_for_growth: Option<u64>, 67 68 /// Size, in bytes, of guard pages for linear memories. 69 pub memory_guard_size: Option<u64>, 70 71 /// Indicates whether an unmapped region of memory is placed before all 72 /// linear memories. 73 pub guard_before_linear_memory: Option<bool>, 74 75 /// Whether to initialize tables lazily, so that instantiation is 76 /// fast but indirect calls are a little slower. If no, tables are 77 /// initialized eagerly from any active element segments that apply to 78 /// them during instantiation. (default: yes) 79 pub table_lazy_init: Option<bool>, 80 81 /// Enable the pooling allocator, in place of the on-demand allocator. 82 pub pooling_allocator: Option<bool>, 83 84 /// The number of decommits to do per batch. A batch size of 1 85 /// effectively disables decommit batching. (default: 1) 86 pub pooling_decommit_batch_size: Option<usize>, 87 88 /// How many bytes to keep resident between instantiations for the 89 /// pooling allocator in linear memories. 90 pub pooling_memory_keep_resident: Option<usize>, 91 92 /// How many bytes to keep resident between instantiations for the 93 /// pooling allocator in tables. 94 pub pooling_table_keep_resident: Option<usize>, 95 96 /// Enable memory protection keys for the pooling allocator; this can 97 /// optimize the size of memory slots. 98 #[serde(default)] 99 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")] 100 pub pooling_memory_protection_keys: Option<wasmtime::MpkEnabled>, 101 102 /// Sets an upper limit on how many memory protection keys (MPK) Wasmtime 103 /// will use. (default: 16) 104 pub pooling_max_memory_protection_keys: Option<usize>, 105 106 /// Configure attempting to initialize linear memory via a 107 /// copy-on-write mapping (default: yes) 108 pub memory_init_cow: Option<bool>, 109 110 /// Threshold below which CoW images are guaranteed to be used and be 111 /// dense. 112 pub memory_guaranteed_dense_image_size: Option<u64>, 113 114 /// The maximum number of WebAssembly instances which can be created 115 /// with the pooling allocator. 116 pub pooling_total_core_instances: Option<u32>, 117 118 /// The maximum number of WebAssembly components which can be created 119 /// with the pooling allocator. 120 pub pooling_total_component_instances: Option<u32>, 121 122 /// The maximum number of WebAssembly memories which can be created with 123 /// the pooling allocator. 124 pub pooling_total_memories: Option<u32>, 125 126 /// The maximum number of WebAssembly tables which can be created with 127 /// the pooling allocator. 128 pub pooling_total_tables: Option<u32>, 129 130 /// The maximum number of WebAssembly stacks which can be created with 131 /// the pooling allocator. 132 pub pooling_total_stacks: Option<u32>, 133 134 /// The maximum runtime size of each linear memory in the pooling 135 /// allocator, in bytes. 136 pub pooling_max_memory_size: Option<usize>, 137 138 /// The maximum table elements for any table defined in a module when 139 /// using the pooling allocator. 140 pub pooling_table_elements: Option<usize>, 141 142 /// The maximum size, in bytes, allocated for a core instance's metadata 143 /// when using the pooling allocator. 144 pub pooling_max_core_instance_size: Option<usize>, 145 146 /// Configures the maximum number of "unused warm slots" to retain in the 147 /// pooling allocator. (default: 100) 148 pub pooling_max_unused_warm_slots: Option<u32>, 149 150 /// How much memory, in bytes, to keep resident for async stacks allocated 151 /// with the pooling allocator. (default: 0) 152 pub pooling_async_stack_keep_resident: Option<usize>, 153 154 /// The maximum size, in bytes, allocated for a component instance's 155 /// `VMComponentContext` metadata. (default: 1MiB) 156 pub pooling_max_component_instance_size: Option<usize>, 157 158 /// The maximum number of core instances a single component may contain 159 /// (default is unlimited). 160 pub pooling_max_core_instances_per_component: Option<u32>, 161 162 /// The maximum number of Wasm linear memories that a single component may 163 /// transitively contain (default is unlimited). 164 pub pooling_max_memories_per_component: Option<u32>, 165 166 /// The maximum number of tables that a single component may transitively 167 /// contain (default is unlimited). 168 pub pooling_max_tables_per_component: Option<u32>, 169 170 /// The maximum number of defined tables for a core module. (default: 1) 171 pub pooling_max_tables_per_module: Option<u32>, 172 173 /// The maximum number of defined linear memories for a module. (default: 1) 174 pub pooling_max_memories_per_module: Option<u32>, 175 176 /// The maximum number of concurrent GC heaps supported. (default: 1000) 177 pub pooling_total_gc_heaps: Option<u32>, 178 179 /// Enable or disable the use of host signal handlers for traps. 180 pub signals_based_traps: Option<bool>, 181 182 /// DEPRECATED: Use `-Cmemory-guard-size=N` instead. 183 pub dynamic_memory_guard_size: Option<u64>, 184 185 /// DEPRECATED: Use `-Cmemory-guard-size=N` instead. 186 pub static_memory_guard_size: Option<u64>, 187 188 /// DEPRECATED: Use `-Cmemory-may-move` instead. 189 pub static_memory_forced: Option<bool>, 190 191 /// DEPRECATED: Use `-Cmemory-reservation=N` instead. 192 pub static_memory_maximum_size: Option<u64>, 193 194 /// DEPRECATED: Use `-Cmemory-reservation-for-growth=N` instead. 195 pub dynamic_memory_reserved_for_growth: Option<u64>, 196 } 197 198 enum Optimize { 199 ... 200 } 201 } 202 203 wasmtime_option_group! { 204 #[derive(PartialEq, Clone, Deserialize)] 205 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 206 pub struct CodegenOptions { 207 /// Either `cranelift` or `winch`. 208 /// 209 /// Currently only `cranelift` and `winch` are supported, but not all 210 /// builds of Wasmtime have both built in. 211 #[serde(default)] 212 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")] 213 pub compiler: Option<wasmtime::Strategy>, 214 /// Which garbage collector to use: `drc` or `null`. 215 /// 216 /// `drc` is the deferred reference-counting collector. 217 /// 218 /// `null` is the null garbage collector, which does not collect any 219 /// garbage. 220 /// 221 /// Note that not all builds of Wasmtime will have support for garbage 222 /// collection included. 223 #[serde(default)] 224 #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")] 225 pub collector: Option<wasmtime::Collector>, 226 /// Enable Cranelift's internal debug verifier (expensive) 227 pub cranelift_debug_verifier: Option<bool>, 228 /// Whether or not to enable caching of compiled modules. 229 pub cache: Option<bool>, 230 /// Configuration for compiled module caching. 231 pub cache_config: Option<String>, 232 /// Whether or not to enable parallel compilation of modules. 233 pub parallel_compilation: Option<bool>, 234 /// Whether to enable proof-carrying code (PCC)-based validation. 235 pub pcc: Option<bool>, 236 /// Controls whether native unwind information is present in compiled 237 /// object files. 238 pub native_unwind_info: Option<bool>, 239 240 #[prefixed = "cranelift"] 241 #[serde(default)] 242 /// Set a cranelift-specific option. Use `wasmtime settings` to see 243 /// all. 244 pub cranelift: Vec<(String, Option<String>)>, 245 } 246 247 enum Codegen { 248 ... 249 } 250 } 251 252 wasmtime_option_group! { 253 #[derive(PartialEq, Clone, Deserialize)] 254 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 255 pub struct DebugOptions { 256 /// Enable generation of DWARF debug information in compiled code. 257 pub debug_info: Option<bool>, 258 /// Configure whether compiled code can map native addresses to wasm. 259 pub address_map: Option<bool>, 260 /// Configure whether logging is enabled. 261 pub logging: Option<bool>, 262 /// Configure whether logs are emitted to files 263 pub log_to_files: Option<bool>, 264 /// Enable coredump generation to this file after a WebAssembly trap. 265 pub coredump: Option<String>, 266 } 267 268 enum Debug { 269 ... 270 } 271 } 272 273 wasmtime_option_group! { 274 #[derive(PartialEq, Clone, Deserialize)] 275 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 276 pub struct WasmOptions { 277 /// Enable canonicalization of all NaN values. 278 pub nan_canonicalization: Option<bool>, 279 /// Enable execution fuel with N units fuel, trapping after running out 280 /// of fuel. 281 /// 282 /// Most WebAssembly instructions consume 1 unit of fuel. Some 283 /// instructions, such as `nop`, `drop`, `block`, and `loop`, consume 0 284 /// units, as any execution cost associated with them involves other 285 /// instructions which do consume fuel. 286 pub fuel: Option<u64>, 287 /// Yield when a global epoch counter changes, allowing for async 288 /// operation without blocking the executor. 289 pub epoch_interruption: Option<bool>, 290 /// Maximum stack size, in bytes, that wasm is allowed to consume before a 291 /// stack overflow is reported. 292 pub max_wasm_stack: Option<usize>, 293 /// Stack size, in bytes, that will be allocated for async stacks. 294 /// 295 /// Note that this must be larger than `max-wasm-stack` and the 296 /// difference between the two is how much stack the host has to execute 297 /// on. 298 pub async_stack_size: Option<usize>, 299 /// Configures whether or not stacks used for async futures are zeroed 300 /// before (re)use as a defense-in-depth mechanism. (default: false) 301 pub async_stack_zeroing: Option<bool>, 302 /// Allow unknown exports when running commands. 303 pub unknown_exports_allow: Option<bool>, 304 /// Allow the main module to import unknown functions, using an 305 /// implementation that immediately traps, when running commands. 306 pub unknown_imports_trap: Option<bool>, 307 /// Allow the main module to import unknown functions, using an 308 /// implementation that returns default values, when running commands. 309 pub unknown_imports_default: Option<bool>, 310 /// Enables memory error checking. (see wmemcheck.md for more info) 311 pub wmemcheck: Option<bool>, 312 /// Maximum size, in bytes, that a linear memory is allowed to reach. 313 /// 314 /// Growth beyond this limit will cause `memory.grow` instructions in 315 /// WebAssembly modules to return -1 and fail. 316 pub max_memory_size: Option<usize>, 317 /// Maximum size, in table elements, that a table is allowed to reach. 318 pub max_table_elements: Option<usize>, 319 /// Maximum number of WebAssembly instances allowed to be created. 320 pub max_instances: Option<usize>, 321 /// Maximum number of WebAssembly tables allowed to be created. 322 pub max_tables: Option<usize>, 323 /// Maximum number of WebAssembly linear memories allowed to be created. 324 pub max_memories: Option<usize>, 325 /// Force a trap to be raised on `memory.grow` and `table.grow` failure 326 /// instead of returning -1 from these instructions. 327 /// 328 /// This is not necessarily a spec-compliant option to enable but can be 329 /// useful for tracking down a backtrace of what is requesting so much 330 /// memory, for example. 331 pub trap_on_grow_failure: Option<bool>, 332 /// Maximum execution time of wasm code before timing out (1, 2s, 100ms, etc) 333 pub timeout: Option<Duration>, 334 /// Configures support for all WebAssembly proposals implemented. 335 pub all_proposals: Option<bool>, 336 /// Configure support for the bulk memory proposal. 337 pub bulk_memory: Option<bool>, 338 /// Configure support for the multi-memory proposal. 339 pub multi_memory: Option<bool>, 340 /// Configure support for the multi-value proposal. 341 pub multi_value: Option<bool>, 342 /// Configure support for the reference-types proposal. 343 pub reference_types: Option<bool>, 344 /// Configure support for the simd proposal. 345 pub simd: Option<bool>, 346 /// Configure support for the relaxed-simd proposal. 347 pub relaxed_simd: Option<bool>, 348 /// Configure forcing deterministic and host-independent behavior of 349 /// the relaxed-simd instructions. 350 /// 351 /// By default these instructions may have architecture-specific behavior as 352 /// allowed by the specification, but this can be used to force the behavior 353 /// of these instructions to match the deterministic behavior classified in 354 /// the specification. Note that enabling this option may come at a 355 /// performance cost. 356 pub relaxed_simd_deterministic: Option<bool>, 357 /// Configure support for the tail-call proposal. 358 pub tail_call: Option<bool>, 359 /// Configure support for the threads proposal. 360 pub threads: Option<bool>, 361 /// Configure support for the shared-everything-threads proposal. 362 pub shared_everything_threads: Option<bool>, 363 /// Configure support for the memory64 proposal. 364 pub memory64: Option<bool>, 365 /// Configure support for the component-model proposal. 366 pub component_model: Option<bool>, 367 /// Component model support for async lifting/lowering. 368 pub component_model_async: Option<bool>, 369 /// Component model support for async lifting/lowering: this corresponds 370 /// to the �� emoji in the component model specification. 371 pub component_model_async_builtins: Option<bool>, 372 /// Component model support for async lifting/lowering: this corresponds 373 /// to the �� emoji in the component model specification. 374 pub component_model_async_stackful: Option<bool>, 375 /// Component model support for `error-context`: this corresponds 376 /// to the �� emoji in the component model specification. 377 pub component_model_error_context: Option<bool>, 378 /// Configure support for the function-references proposal. 379 pub function_references: Option<bool>, 380 /// Configure support for the GC proposal. 381 pub gc: Option<bool>, 382 /// Configure support for the custom-page-sizes proposal. 383 pub custom_page_sizes: Option<bool>, 384 /// Configure support for the wide-arithmetic proposal. 385 pub wide_arithmetic: Option<bool>, 386 /// Configure support for the extended-const proposal. 387 pub extended_const: Option<bool>, 388 /// Configure support for the exceptions proposal. 389 pub exceptions: Option<bool>, 390 /// DEPRECATED: Configure support for the legacy exceptions proposal. 391 pub legacy_exceptions: Option<bool>, 392 } 393 394 enum Wasm { 395 ... 396 } 397 } 398 399 wasmtime_option_group! { 400 #[derive(PartialEq, Clone, Deserialize)] 401 #[serde(rename_all = "kebab-case", deny_unknown_fields)] 402 pub struct WasiOptions { 403 /// Enable support for WASI CLI APIs, including filesystems, sockets, clocks, and random. 404 pub cli: Option<bool>, 405 /// Enable WASI APIs marked as: @unstable(feature = cli-exit-with-code) 406 pub cli_exit_with_code: Option<bool>, 407 /// Deprecated alias for `cli` 408 pub common: Option<bool>, 409 /// Enable support for WASI neural network imports (experimental) 410 pub nn: Option<bool>, 411 /// Enable support for WASI threading imports (experimental). Implies preview2=false. 412 pub threads: Option<bool>, 413 /// Enable support for WASI HTTP imports 414 pub http: Option<bool>, 415 /// Number of distinct write calls to the outgoing body's output-stream 416 /// that the implementation will buffer. 417 /// Default: 1. 418 pub http_outgoing_body_buffer_chunks: Option<usize>, 419 /// Maximum size allowed in a write call to the outgoing body's output-stream. 420 /// Default: 1024 * 1024. 421 pub http_outgoing_body_chunk_size: Option<usize>, 422 /// Enable support for WASI config imports (experimental) 423 pub config: Option<bool>, 424 /// Enable support for WASI key-value imports (experimental) 425 pub keyvalue: Option<bool>, 426 /// Inherit environment variables and file descriptors following the 427 /// systemd listen fd specification (UNIX only) (legacy wasip1 428 /// implementation only) 429 pub listenfd: Option<bool>, 430 /// Grant access to the given TCP listen socket (experimental, legacy 431 /// wasip1 implementation only) 432 #[serde(default)] 433 pub tcplisten: Vec<String>, 434 /// Enable support for WASI TLS (Transport Layer Security) imports (experimental) 435 pub tls: Option<bool>, 436 /// Implement WASI Preview1 using new Preview2 implementation (true, default) or legacy 437 /// implementation (false) 438 pub preview2: Option<bool>, 439 /// Pre-load machine learning graphs (i.e., models) for use by wasi-nn. 440 /// 441 /// Each use of the flag will preload a ML model from the host directory 442 /// using the given model encoding. The model will be mapped to the 443 /// directory name: e.g., `--wasi-nn-graph openvino:/foo/bar` will preload 444 /// an OpenVINO model named `bar`. Note that which model encodings are 445 /// available is dependent on the backends implemented in the 446 /// `wasmtime_wasi_nn` crate. 447 #[serde(skip)] 448 pub nn_graph: Vec<WasiNnGraph>, 449 /// Flag for WASI preview2 to inherit the host's network within the 450 /// guest so it has full access to all addresses/ports/etc. 451 pub inherit_network: Option<bool>, 452 /// Indicates whether `wasi:sockets/ip-name-lookup` is enabled or not. 453 pub allow_ip_name_lookup: Option<bool>, 454 /// Indicates whether `wasi:sockets` TCP support is enabled or not. 455 pub tcp: Option<bool>, 456 /// Indicates whether `wasi:sockets` UDP support is enabled or not. 457 pub udp: Option<bool>, 458 /// Enable WASI APIs marked as: @unstable(feature = network-error-code) 459 pub network_error_code: Option<bool>, 460 /// Allows imports from the `wasi_unstable` core wasm module. 461 pub preview0: Option<bool>, 462 /// Inherit all environment variables from the parent process. 463 /// 464 /// This option can be further overwritten with `--env` flags. 465 pub inherit_env: Option<bool>, 466 /// Pass a wasi config variable to the program. 467 #[serde(skip)] 468 pub config_var: Vec<KeyValuePair>, 469 /// Preset data for the In-Memory provider of WASI key-value API. 470 #[serde(skip)] 471 pub keyvalue_in_memory_data: Vec<KeyValuePair>, 472 } 473 474 enum Wasi { 475 ... 476 } 477 } 478 479 #[derive(Debug, Clone, PartialEq)] 480 pub struct WasiNnGraph { 481 pub format: String, 482 pub dir: String, 483 } 484 485 #[derive(Debug, Clone, PartialEq)] 486 pub struct KeyValuePair { 487 pub key: String, 488 pub value: String, 489 } 490 491 /// Common options for commands that translate WebAssembly modules 492 #[derive(Parser, Clone, Deserialize)] 493 #[serde(deny_unknown_fields)] 494 pub struct CommonOptions { 495 // These options groups are used to parse `-O` and such options but aren't 496 // the raw form consumed by the CLI. Instead they're pushed into the `pub` 497 // fields below as part of the `configure` method. 498 // 499 // Ideally clap would support `pub opts: OptimizeOptions` and parse directly 500 // into that but it does not appear to do so for multiple `-O` flags for 501 // now. 502 /// Optimization and tuning related options for wasm performance, `-O help` to 503 /// see all. 504 #[arg(short = 'O', long = "optimize", value_name = "KEY[=VAL[,..]]")] 505 #[serde(skip)] 506 opts_raw: Vec<opt::CommaSeparated<Optimize>>, 507 508 /// Codegen-related configuration options, `-C help` to see all. 509 #[arg(short = 'C', long = "codegen", value_name = "KEY[=VAL[,..]]")] 510 #[serde(skip)] 511 codegen_raw: Vec<opt::CommaSeparated<Codegen>>, 512 513 /// Debug-related configuration options, `-D help` to see all. 514 #[arg(short = 'D', long = "debug", value_name = "KEY[=VAL[,..]]")] 515 #[serde(skip)] 516 debug_raw: Vec<opt::CommaSeparated<Debug>>, 517 518 /// Options for configuring semantic execution of WebAssembly, `-W help` to see 519 /// all. 520 #[arg(short = 'W', long = "wasm", value_name = "KEY[=VAL[,..]]")] 521 #[serde(skip)] 522 wasm_raw: Vec<opt::CommaSeparated<Wasm>>, 523 524 /// Options for configuring WASI and its proposals, `-S help` to see all. 525 #[arg(short = 'S', long = "wasi", value_name = "KEY[=VAL[,..]]")] 526 #[serde(skip)] 527 wasi_raw: Vec<opt::CommaSeparated<Wasi>>, 528 529 // These fields are filled in by the `configure` method below via the 530 // options parsed from the CLI above. This is what the CLI should use. 531 #[arg(skip)] 532 #[serde(skip)] 533 configured: bool, 534 535 #[arg(skip)] 536 #[serde(rename = "optimize", default)] 537 pub opts: OptimizeOptions, 538 539 #[arg(skip)] 540 #[serde(rename = "codegen", default)] 541 pub codegen: CodegenOptions, 542 543 #[arg(skip)] 544 #[serde(rename = "debug", default)] 545 pub debug: DebugOptions, 546 547 #[arg(skip)] 548 #[serde(rename = "wasm", default)] 549 pub wasm: WasmOptions, 550 551 #[arg(skip)] 552 #[serde(rename = "wasi", default)] 553 pub wasi: WasiOptions, 554 555 /// The target triple; default is the host triple 556 #[arg(long, value_name = "TARGET")] 557 #[serde(skip)] 558 pub target: Option<String>, 559 560 /// Use the specified TOML configuration file. 561 /// This TOML configuration file can provide same configuration options as the 562 /// `--optimize`, `--codgen`, `--debug`, `--wasm`, `--wasi` CLI options, with a couple exceptions. 563 /// 564 /// Additional options specified on the command line will take precedent over options loaded from 565 /// this TOML file. 566 #[arg(long = "config", value_name = "FILE")] 567 #[serde(skip)] 568 pub config: Option<PathBuf>, 569 } 570 571 macro_rules! match_feature { 572 ( 573 [$feat:tt : $config:expr] 574 $val:ident => $e:expr, 575 $p:pat => err, 576 ) => { 577 #[cfg(feature = $feat)] 578 { 579 if let Some($val) = $config { 580 $e; 581 } 582 } 583 #[cfg(not(feature = $feat))] 584 { 585 if let Some($p) = $config { 586 anyhow::bail!(concat!("support for ", $feat, " disabled at compile time")); 587 } 588 } 589 }; 590 } 591 592 impl CommonOptions { 593 /// Creates a blank new set of [`CommonOptions`] that can be configured. 594 pub fn new() -> CommonOptions { 595 CommonOptions { 596 opts_raw: Vec::new(), 597 codegen_raw: Vec::new(), 598 debug_raw: Vec::new(), 599 wasm_raw: Vec::new(), 600 wasi_raw: Vec::new(), 601 configured: true, 602 opts: Default::default(), 603 codegen: Default::default(), 604 debug: Default::default(), 605 wasm: Default::default(), 606 wasi: Default::default(), 607 target: None, 608 config: None, 609 } 610 } 611 612 fn configure(&mut self) -> Result<()> { 613 if self.configured { 614 return Ok(()); 615 } 616 self.configured = true; 617 if let Some(toml_config_path) = &self.config { 618 let toml_options = CommonOptions::from_file(toml_config_path)?; 619 self.opts = toml_options.opts; 620 self.codegen = toml_options.codegen; 621 self.debug = toml_options.debug; 622 self.wasm = toml_options.wasm; 623 self.wasi = toml_options.wasi; 624 } 625 self.opts.configure_with(&self.opts_raw); 626 self.codegen.configure_with(&self.codegen_raw); 627 self.debug.configure_with(&self.debug_raw); 628 self.wasm.configure_with(&self.wasm_raw); 629 self.wasi.configure_with(&self.wasi_raw); 630 Ok(()) 631 } 632 633 pub fn init_logging(&mut self) -> Result<()> { 634 self.configure()?; 635 if self.debug.logging == Some(false) { 636 return Ok(()); 637 } 638 #[cfg(feature = "logging")] 639 if self.debug.log_to_files == Some(true) { 640 let prefix = "wasmtime.dbg."; 641 init_file_per_thread_logger(prefix); 642 } else { 643 use std::io::IsTerminal; 644 use tracing_subscriber::{EnvFilter, FmtSubscriber}; 645 let builder = FmtSubscriber::builder() 646 .with_writer(std::io::stderr) 647 .with_env_filter(EnvFilter::from_env("WASMTIME_LOG")) 648 .with_ansi(std::io::stderr().is_terminal()); 649 if std::env::var("WASMTIME_LOG_NO_CONTEXT").is_ok_and(|value| value.eq("1")) { 650 builder 651 .with_level(false) 652 .with_target(false) 653 .without_time() 654 .init() 655 } else { 656 builder.init(); 657 } 658 } 659 #[cfg(not(feature = "logging"))] 660 if self.debug.log_to_files == Some(true) || self.debug.logging == Some(true) { 661 anyhow::bail!("support for logging disabled at compile time"); 662 } 663 Ok(()) 664 } 665 666 pub fn config(&mut self, pooling_allocator_default: Option<bool>) -> Result<Config> { 667 self.configure()?; 668 let mut config = Config::new(); 669 670 match_feature! { 671 ["cranelift" : self.codegen.compiler] 672 strategy => config.strategy(strategy), 673 _ => err, 674 } 675 match_feature! { 676 ["gc" : self.codegen.collector] 677 collector => config.collector(collector), 678 _ => err, 679 } 680 if let Some(target) = &self.target { 681 config.target(target)?; 682 } 683 match_feature! { 684 ["cranelift" : self.codegen.cranelift_debug_verifier] 685 enable => config.cranelift_debug_verifier(enable), 686 true => err, 687 } 688 if let Some(enable) = self.debug.debug_info { 689 config.debug_info(enable); 690 } 691 if self.debug.coredump.is_some() { 692 #[cfg(feature = "coredump")] 693 config.coredump_on_trap(true); 694 #[cfg(not(feature = "coredump"))] 695 anyhow::bail!("support for coredumps disabled at compile time"); 696 } 697 match_feature! { 698 ["cranelift" : self.opts.opt_level] 699 level => config.cranelift_opt_level(level), 700 _ => err, 701 } 702 match_feature! { 703 ["cranelift": self.opts.regalloc_algorithm] 704 algo => config.cranelift_regalloc_algorithm(algo), 705 _ => err, 706 } 707 match_feature! { 708 ["cranelift" : self.wasm.nan_canonicalization] 709 enable => config.cranelift_nan_canonicalization(enable), 710 true => err, 711 } 712 match_feature! { 713 ["cranelift" : self.codegen.pcc] 714 enable => config.cranelift_pcc(enable), 715 true => err, 716 } 717 718 self.enable_wasm_features(&mut config)?; 719 720 #[cfg(feature = "cranelift")] 721 for (name, value) in self.codegen.cranelift.iter() { 722 let name = name.replace('-', "_"); 723 unsafe { 724 match value { 725 Some(val) => { 726 config.cranelift_flag_set(&name, val); 727 } 728 None => { 729 config.cranelift_flag_enable(&name); 730 } 731 } 732 } 733 } 734 #[cfg(not(feature = "cranelift"))] 735 if !self.codegen.cranelift.is_empty() { 736 anyhow::bail!("support for cranelift disabled at compile time"); 737 } 738 739 #[cfg(feature = "cache")] 740 if self.codegen.cache != Some(false) { 741 use wasmtime::Cache; 742 let cache = match &self.codegen.cache_config { 743 Some(path) => Cache::from_file(Some(Path::new(path)))?, 744 None => Cache::from_file(None)?, 745 }; 746 config.cache(Some(cache)); 747 } 748 #[cfg(not(feature = "cache"))] 749 if self.codegen.cache == Some(true) { 750 anyhow::bail!("support for caching disabled at compile time"); 751 } 752 753 match_feature! { 754 ["parallel-compilation" : self.codegen.parallel_compilation] 755 enable => config.parallel_compilation(enable), 756 true => err, 757 } 758 759 let memory_reservation = self 760 .opts 761 .memory_reservation 762 .or(self.opts.static_memory_maximum_size); 763 if let Some(size) = memory_reservation { 764 config.memory_reservation(size); 765 } 766 767 if let Some(enable) = self.opts.static_memory_forced { 768 config.memory_may_move(!enable); 769 } 770 if let Some(enable) = self.opts.memory_may_move { 771 config.memory_may_move(enable); 772 } 773 774 let memory_guard_size = self 775 .opts 776 .static_memory_guard_size 777 .or(self.opts.dynamic_memory_guard_size) 778 .or(self.opts.memory_guard_size); 779 if let Some(size) = memory_guard_size { 780 config.memory_guard_size(size); 781 } 782 783 let mem_for_growth = self 784 .opts 785 .memory_reservation_for_growth 786 .or(self.opts.dynamic_memory_reserved_for_growth); 787 if let Some(size) = mem_for_growth { 788 config.memory_reservation_for_growth(size); 789 } 790 if let Some(enable) = self.opts.guard_before_linear_memory { 791 config.guard_before_linear_memory(enable); 792 } 793 if let Some(enable) = self.opts.table_lazy_init { 794 config.table_lazy_init(enable); 795 } 796 797 // If fuel has been configured, set the `consume fuel` flag on the config. 798 if self.wasm.fuel.is_some() { 799 config.consume_fuel(true); 800 } 801 802 if let Some(enable) = self.wasm.epoch_interruption { 803 config.epoch_interruption(enable); 804 } 805 if let Some(enable) = self.debug.address_map { 806 config.generate_address_map(enable); 807 } 808 if let Some(enable) = self.opts.memory_init_cow { 809 config.memory_init_cow(enable); 810 } 811 if let Some(size) = self.opts.memory_guaranteed_dense_image_size { 812 config.memory_guaranteed_dense_image_size(size); 813 } 814 if let Some(enable) = self.opts.signals_based_traps { 815 config.signals_based_traps(enable); 816 } 817 if let Some(enable) = self.codegen.native_unwind_info { 818 config.native_unwind_info(enable); 819 } 820 821 match_feature! { 822 ["pooling-allocator" : self.opts.pooling_allocator.or(pooling_allocator_default)] 823 enable => { 824 if enable { 825 let mut cfg = wasmtime::PoolingAllocationConfig::default(); 826 if let Some(size) = self.opts.pooling_memory_keep_resident { 827 cfg.linear_memory_keep_resident(size); 828 } 829 if let Some(size) = self.opts.pooling_table_keep_resident { 830 cfg.table_keep_resident(size); 831 } 832 if let Some(limit) = self.opts.pooling_total_core_instances { 833 cfg.total_core_instances(limit); 834 } 835 if let Some(limit) = self.opts.pooling_total_component_instances { 836 cfg.total_component_instances(limit); 837 } 838 if let Some(limit) = self.opts.pooling_total_memories { 839 cfg.total_memories(limit); 840 } 841 if let Some(limit) = self.opts.pooling_total_tables { 842 cfg.total_tables(limit); 843 } 844 if let Some(limit) = self.opts.pooling_table_elements 845 .or(self.wasm.max_table_elements) 846 { 847 cfg.table_elements(limit); 848 } 849 if let Some(limit) = self.opts.pooling_max_core_instance_size { 850 cfg.max_core_instance_size(limit); 851 } 852 match_feature! { 853 ["async" : self.opts.pooling_total_stacks] 854 limit => cfg.total_stacks(limit), 855 _ => err, 856 } 857 if let Some(max) = self.opts.pooling_max_memory_size 858 .or(self.wasm.max_memory_size) 859 { 860 cfg.max_memory_size(max); 861 } 862 if let Some(size) = self.opts.pooling_decommit_batch_size { 863 cfg.decommit_batch_size(size); 864 } 865 if let Some(max) = self.opts.pooling_max_unused_warm_slots { 866 cfg.max_unused_warm_slots(max); 867 } 868 match_feature! { 869 ["async" : self.opts.pooling_async_stack_keep_resident] 870 size => cfg.async_stack_keep_resident(size), 871 _ => err, 872 } 873 if let Some(max) = self.opts.pooling_max_component_instance_size { 874 cfg.max_component_instance_size(max); 875 } 876 if let Some(max) = self.opts.pooling_max_core_instances_per_component { 877 cfg.max_core_instances_per_component(max); 878 } 879 if let Some(max) = self.opts.pooling_max_memories_per_component { 880 cfg.max_memories_per_component(max); 881 } 882 if let Some(max) = self.opts.pooling_max_tables_per_component { 883 cfg.max_tables_per_component(max); 884 } 885 if let Some(max) = self.opts.pooling_max_tables_per_module { 886 cfg.max_tables_per_module(max); 887 } 888 if let Some(max) = self.opts.pooling_max_memories_per_module { 889 cfg.max_memories_per_module(max); 890 } 891 match_feature! { 892 ["memory-protection-keys" : self.opts.pooling_memory_protection_keys] 893 enable => cfg.memory_protection_keys(enable), 894 _ => err, 895 } 896 match_feature! { 897 ["memory-protection-keys" : self.opts.pooling_max_memory_protection_keys] 898 max => cfg.max_memory_protection_keys(max), 899 _ => err, 900 } 901 match_feature! { 902 ["gc" : self.opts.pooling_total_gc_heaps] 903 max => cfg.total_gc_heaps(max), 904 _ => err, 905 } 906 config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(cfg)); 907 } 908 }, 909 true => err, 910 } 911 912 if self.opts.pooling_memory_protection_keys.is_some() 913 && !self.opts.pooling_allocator.unwrap_or(false) 914 { 915 anyhow::bail!("memory protection keys require the pooling allocator"); 916 } 917 918 if self.opts.pooling_max_memory_protection_keys.is_some() 919 && !self.opts.pooling_memory_protection_keys.is_some() 920 { 921 anyhow::bail!( 922 "max memory protection keys requires memory protection keys to be enabled" 923 ); 924 } 925 926 match_feature! { 927 ["async" : self.wasm.async_stack_size] 928 size => config.async_stack_size(size), 929 _ => err, 930 } 931 match_feature! { 932 ["async" : self.wasm.async_stack_zeroing] 933 enable => config.async_stack_zeroing(enable), 934 _ => err, 935 } 936 937 if let Some(max) = self.wasm.max_wasm_stack { 938 config.max_wasm_stack(max); 939 940 // If `-Wasync-stack-size` isn't passed then automatically adjust it 941 // to the wasm stack size provided here too. That prevents the need 942 // to pass both when one can generally be inferred from the other. 943 #[cfg(feature = "async")] 944 if self.wasm.async_stack_size.is_none() { 945 const DEFAULT_HOST_STACK: usize = 512 << 10; 946 config.async_stack_size(max + DEFAULT_HOST_STACK); 947 } 948 } 949 950 if let Some(enable) = self.wasm.relaxed_simd_deterministic { 951 config.relaxed_simd_deterministic(enable); 952 } 953 match_feature! { 954 ["cranelift" : self.wasm.wmemcheck] 955 enable => config.wmemcheck(enable), 956 true => err, 957 } 958 959 Ok(config) 960 } 961 962 pub fn enable_wasm_features(&self, config: &mut Config) -> Result<()> { 963 let all = self.wasm.all_proposals; 964 965 if let Some(enable) = self.wasm.simd.or(all) { 966 config.wasm_simd(enable); 967 } 968 if let Some(enable) = self.wasm.relaxed_simd.or(all) { 969 config.wasm_relaxed_simd(enable); 970 } 971 if let Some(enable) = self.wasm.bulk_memory.or(all) { 972 config.wasm_bulk_memory(enable); 973 } 974 if let Some(enable) = self.wasm.multi_value.or(all) { 975 config.wasm_multi_value(enable); 976 } 977 if let Some(enable) = self.wasm.tail_call.or(all) { 978 config.wasm_tail_call(enable); 979 } 980 if let Some(enable) = self.wasm.multi_memory.or(all) { 981 config.wasm_multi_memory(enable); 982 } 983 if let Some(enable) = self.wasm.memory64.or(all) { 984 config.wasm_memory64(enable); 985 } 986 if let Some(enable) = self.wasm.custom_page_sizes.or(all) { 987 config.wasm_custom_page_sizes(enable); 988 } 989 if let Some(enable) = self.wasm.wide_arithmetic.or(all) { 990 config.wasm_wide_arithmetic(enable); 991 } 992 if let Some(enable) = self.wasm.extended_const.or(all) { 993 config.wasm_extended_const(enable); 994 } 995 if let Some(enable) = self.wasm.exceptions.or(all) { 996 config.wasm_exceptions(enable); 997 } 998 if let Some(enable) = self.wasm.legacy_exceptions.or(all) { 999 #[expect(deprecated, reason = "forwarding CLI flag")] 1000 config.wasm_legacy_exceptions(enable); 1001 } 1002 1003 macro_rules! handle_conditionally_compiled { 1004 ($(($feature:tt, $field:tt, $method:tt))*) => ($( 1005 if let Some(enable) = self.wasm.$field.or(all) { 1006 #[cfg(feature = $feature)] 1007 config.$method(enable); 1008 #[cfg(not(feature = $feature))] 1009 if enable && all.is_none() { 1010 anyhow::bail!("support for {} was disabled at compile-time", $feature); 1011 } 1012 } 1013 )*) 1014 } 1015 1016 handle_conditionally_compiled! { 1017 ("component-model", component_model, wasm_component_model) 1018 ("component-model-async", component_model_async, wasm_component_model_async) 1019 ("component-model-async", component_model_async_builtins, wasm_component_model_async_builtins) 1020 ("component-model-async", component_model_async_stackful, wasm_component_model_async_stackful) 1021 ("component-model", component_model_error_context, wasm_component_model_error_context) 1022 ("threads", threads, wasm_threads) 1023 ("gc", gc, wasm_gc) 1024 ("gc", reference_types, wasm_reference_types) 1025 ("gc", function_references, wasm_function_references) 1026 } 1027 Ok(()) 1028 } 1029 1030 pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> { 1031 let path_ref = path.as_ref(); 1032 let file_contents = fs::read_to_string(path_ref) 1033 .with_context(|| format!("failed to read config file: {path_ref:?}"))?; 1034 toml::from_str::<CommonOptions>(&file_contents) 1035 .with_context(|| format!("failed to parse TOML config file {path_ref:?}")) 1036 } 1037 } 1038 1039 #[cfg(test)] 1040 mod tests { 1041 use wasmtime::{OptLevel, RegallocAlgorithm}; 1042 1043 use super::*; 1044 1045 #[test] 1046 fn from_toml() { 1047 // empty toml 1048 let empty_toml = ""; 1049 let mut common_options: CommonOptions = toml::from_str(empty_toml).unwrap(); 1050 common_options.config(None).unwrap(); 1051 1052 // basic toml 1053 let basic_toml = r#" 1054 [optimize] 1055 [codegen] 1056 [debug] 1057 [wasm] 1058 [wasi] 1059 "#; 1060 let mut common_options: CommonOptions = toml::from_str(basic_toml).unwrap(); 1061 common_options.config(None).unwrap(); 1062 1063 // toml with custom deserialization to match CLI flag parsing 1064 for (opt_value, expected) in [ 1065 ("0", Some(OptLevel::None)), 1066 ("1", Some(OptLevel::Speed)), 1067 ("2", Some(OptLevel::Speed)), 1068 ("\"s\"", Some(OptLevel::SpeedAndSize)), 1069 ("\"hello\"", None), // should fail 1070 ("3", None), // should fail 1071 ] { 1072 let toml = format!( 1073 r#" 1074 [optimize] 1075 opt-level = {opt_value} 1076 "#, 1077 ); 1078 let parsed_opt_level = toml::from_str::<CommonOptions>(&toml) 1079 .ok() 1080 .and_then(|common_options| common_options.opts.opt_level); 1081 1082 assert_eq!( 1083 parsed_opt_level, expected, 1084 "Mismatch for input '{opt_value}'. Parsed: {parsed_opt_level:?}, Expected: {expected:?}" 1085 ); 1086 } 1087 1088 // Regalloc algorithm 1089 for (regalloc_value, expected) in [ 1090 ("\"backtracking\"", Some(RegallocAlgorithm::Backtracking)), 1091 ("\"hello\"", None), // should fail 1092 ("3", None), // should fail 1093 ("true", None), // should fail 1094 ] { 1095 let toml = format!( 1096 r#" 1097 [optimize] 1098 regalloc-algorithm = {regalloc_value} 1099 "#, 1100 ); 1101 let parsed_regalloc_algorithm = toml::from_str::<CommonOptions>(&toml) 1102 .ok() 1103 .and_then(|common_options| common_options.opts.regalloc_algorithm); 1104 assert_eq!( 1105 parsed_regalloc_algorithm, expected, 1106 "Mismatch for input '{regalloc_value}'. Parsed: {parsed_regalloc_algorithm:?}, Expected: {expected:?}" 1107 ); 1108 } 1109 1110 // Strategy 1111 for (strategy_value, expected) in [ 1112 ("\"cranelift\"", Some(wasmtime::Strategy::Cranelift)), 1113 ("\"winch\"", Some(wasmtime::Strategy::Winch)), 1114 ("\"hello\"", None), // should fail 1115 ("5", None), // should fail 1116 ("true", None), // should fail 1117 ] { 1118 let toml = format!( 1119 r#" 1120 [codegen] 1121 compiler = {strategy_value} 1122 "#, 1123 ); 1124 let parsed_strategy = toml::from_str::<CommonOptions>(&toml) 1125 .ok() 1126 .and_then(|common_options| common_options.codegen.compiler); 1127 assert_eq!( 1128 parsed_strategy, expected, 1129 "Mismatch for input '{strategy_value}'. Parsed: {parsed_strategy:?}, Expected: {expected:?}", 1130 ); 1131 } 1132 1133 // Collector 1134 for (collector_value, expected) in [ 1135 ( 1136 "\"drc\"", 1137 Some(wasmtime::Collector::DeferredReferenceCounting), 1138 ), 1139 ("\"null\"", Some(wasmtime::Collector::Null)), 1140 ("\"hello\"", None), // should fail 1141 ("5", None), // should fail 1142 ("true", None), // should fail 1143 ] { 1144 let toml = format!( 1145 r#" 1146 [codegen] 1147 collector = {collector_value} 1148 "#, 1149 ); 1150 let parsed_collector = toml::from_str::<CommonOptions>(&toml) 1151 .ok() 1152 .and_then(|common_options| common_options.codegen.collector); 1153 assert_eq!( 1154 parsed_collector, expected, 1155 "Mismatch for input '{collector_value}'. Parsed: {parsed_collector:?}, Expected: {expected:?}", 1156 ); 1157 } 1158 } 1159 } 1160 1161 impl Default for CommonOptions { 1162 fn default() -> CommonOptions { 1163 CommonOptions::new() 1164 } 1165 } 1166 1167 impl fmt::Display for CommonOptions { 1168 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 1169 let CommonOptions { 1170 codegen_raw, 1171 codegen, 1172 debug_raw, 1173 debug, 1174 opts_raw, 1175 opts, 1176 wasm_raw, 1177 wasm, 1178 wasi_raw, 1179 wasi, 1180 configured, 1181 target, 1182 config, 1183 } = self; 1184 if let Some(target) = target { 1185 write!(f, "--target {target} ")?; 1186 } 1187 if let Some(config) = config { 1188 write!(f, "--config {} ", config.display())?; 1189 } 1190 1191 let codegen_flags; 1192 let opts_flags; 1193 let wasi_flags; 1194 let wasm_flags; 1195 let debug_flags; 1196 1197 if *configured { 1198 codegen_flags = codegen.to_options(); 1199 debug_flags = debug.to_options(); 1200 wasi_flags = wasi.to_options(); 1201 wasm_flags = wasm.to_options(); 1202 opts_flags = opts.to_options(); 1203 } else { 1204 codegen_flags = codegen_raw 1205 .iter() 1206 .flat_map(|t| t.0.iter()) 1207 .cloned() 1208 .collect(); 1209 debug_flags = debug_raw.iter().flat_map(|t| t.0.iter()).cloned().collect(); 1210 wasi_flags = wasi_raw.iter().flat_map(|t| t.0.iter()).cloned().collect(); 1211 wasm_flags = wasm_raw.iter().flat_map(|t| t.0.iter()).cloned().collect(); 1212 opts_flags = opts_raw.iter().flat_map(|t| t.0.iter()).cloned().collect(); 1213 } 1214 1215 for flag in codegen_flags { 1216 write!(f, "-C{flag} ")?; 1217 } 1218 for flag in opts_flags { 1219 write!(f, "-O{flag} ")?; 1220 } 1221 for flag in wasi_flags { 1222 write!(f, "-S{flag} ")?; 1223 } 1224 for flag in wasm_flags { 1225 write!(f, "-W{flag} ")?; 1226 } 1227 for flag in debug_flags { 1228 write!(f, "-D{flag} ")?; 1229 } 1230 1231 Ok(()) 1232 } 1233 } 1234