1 //! Contains the common Wasmtime command line interface (CLI) flags. 2 3 use anyhow::Result; 4 use clap::Parser; 5 use std::time::Duration; 6 use wasmtime::Config; 7 8 pub mod opt; 9 10 #[cfg(feature = "logging")] 11 fn init_file_per_thread_logger(prefix: &'static str) { 12 file_per_thread_logger::initialize(prefix); 13 file_per_thread_logger::allow_uninitialized(); 14 15 // Extending behavior of default spawner: 16 // https://docs.rs/rayon/1.1.0/rayon/struct.ThreadPoolBuilder.html#method.spawn_handler 17 // Source code says DefaultSpawner is implementation detail and 18 // shouldn't be used directly. 19 #[cfg(feature = "parallel-compilation")] 20 rayon::ThreadPoolBuilder::new() 21 .spawn_handler(move |thread| { 22 let mut b = std::thread::Builder::new(); 23 if let Some(name) = thread.name() { 24 b = b.name(name.to_owned()); 25 } 26 if let Some(stack_size) = thread.stack_size() { 27 b = b.stack_size(stack_size); 28 } 29 b.spawn(move || { 30 file_per_thread_logger::initialize(prefix); 31 thread.run() 32 })?; 33 Ok(()) 34 }) 35 .build_global() 36 .unwrap(); 37 } 38 39 wasmtime_option_group! { 40 #[derive(PartialEq, Clone)] 41 pub struct OptimizeOptions { 42 /// Optimization level of generated code (0-2, s; default: 2) 43 pub opt_level: Option<wasmtime::OptLevel>, 44 45 /// Byte size of the guard region after dynamic memories are allocated 46 pub dynamic_memory_guard_size: Option<u64>, 47 48 /// Force using a "static" style for all wasm memories 49 pub static_memory_forced: Option<bool>, 50 51 /// Maximum size in bytes of wasm memory before it becomes dynamically 52 /// relocatable instead of up-front-reserved. 53 pub static_memory_maximum_size: Option<u64>, 54 55 /// Byte size of the guard region after static memories are allocated 56 pub static_memory_guard_size: Option<u64>, 57 58 /// Bytes to reserve at the end of linear memory for growth for dynamic 59 /// memories. 60 pub dynamic_memory_reserved_for_growth: Option<u64>, 61 62 /// Indicates whether an unmapped region of memory is placed before all 63 /// linear memories. 64 pub guard_before_linear_memory: Option<bool>, 65 66 /// Whether to initialize tables lazily, so that instantiation is 67 /// fast but indirect calls are a little slower. If no, tables are 68 /// initialized eagerly from any active element segments that apply to 69 /// them during instantiation. (default: yes) 70 pub table_lazy_init: Option<bool>, 71 72 /// Enable the pooling allocator, in place of the on-demand allocator. 73 pub pooling_allocator: Option<bool>, 74 75 /// The number of decommits to do per batch. A batch size of 1 76 /// effectively disables decommit batching. (default: 1) 77 pub pooling_decommit_batch_size: Option<u32>, 78 79 /// How many bytes to keep resident between instantiations for the 80 /// pooling allocator in linear memories. 81 pub pooling_memory_keep_resident: Option<usize>, 82 83 /// How many bytes to keep resident between instantiations for the 84 /// pooling allocator in tables. 85 pub pooling_table_keep_resident: Option<usize>, 86 87 /// Enable memory protection keys for the pooling allocator; this can 88 /// optimize the size of memory slots. 89 pub memory_protection_keys: Option<bool>, 90 91 /// Configure attempting to initialize linear memory via a 92 /// copy-on-write mapping (default: yes) 93 pub memory_init_cow: Option<bool>, 94 95 /// The maximum number of WebAssembly instances which can be created 96 /// with the pooling allocator. 97 pub pooling_total_core_instances: Option<u32>, 98 99 /// The maximum number of WebAssembly components which can be created 100 /// with the pooling allocator. 101 pub pooling_total_component_instances: Option<u32>, 102 103 /// The maximum number of WebAssembly memories which can be created with 104 /// the pooling allocator. 105 pub pooling_total_memories: Option<u32>, 106 107 /// The maximum number of WebAssembly tables which can be created with 108 /// the pooling allocator. 109 pub pooling_total_tables: Option<u32>, 110 111 /// The maximum number of WebAssembly stacks which can be created with 112 /// the pooling allocator. 113 pub pooling_total_stacks: Option<u32>, 114 115 /// The maximum runtime size of each linear memory in the pooling 116 /// allocator, in bytes. 117 pub pooling_max_memory_size: Option<usize>, 118 } 119 120 enum Optimize { 121 ... 122 } 123 } 124 125 wasmtime_option_group! { 126 #[derive(PartialEq, Clone)] 127 pub struct CodegenOptions { 128 /// Either `cranelift` or `winch`. 129 /// 130 /// Currently only `cranelift` and `winch` are supported, but not all 131 /// builds of Wasmtime have both built in. 132 pub compiler: Option<wasmtime::Strategy>, 133 /// Enable Cranelift's internal debug verifier (expensive) 134 pub cranelift_debug_verifier: Option<bool>, 135 /// Whether or not to enable caching of compiled modules. 136 pub cache: Option<bool>, 137 /// Configuration for compiled module caching. 138 pub cache_config: Option<String>, 139 /// Whether or not to enable parallel compilation of modules. 140 pub parallel_compilation: Option<bool>, 141 /// Whether to enable proof-carrying code (PCC)-based validation. 142 pub pcc: Option<bool>, 143 144 #[prefixed = "cranelift"] 145 /// Set a cranelift-specific option. Use `wasmtime settings` to see 146 /// all. 147 pub cranelift: Vec<(String, Option<String>)>, 148 } 149 150 enum Codegen { 151 ... 152 } 153 } 154 155 wasmtime_option_group! { 156 #[derive(PartialEq, Clone)] 157 pub struct DebugOptions { 158 /// Enable generation of DWARF debug information in compiled code. 159 pub debug_info: Option<bool>, 160 /// Configure whether compiled code can map native addresses to wasm. 161 pub address_map: Option<bool>, 162 /// Configure whether logging is enabled. 163 pub logging: Option<bool>, 164 /// Configure whether logs are emitted to files 165 pub log_to_files: Option<bool>, 166 /// Enable coredump generation to this file after a WebAssembly trap. 167 pub coredump: Option<String>, 168 } 169 170 enum Debug { 171 ... 172 } 173 } 174 175 wasmtime_option_group! { 176 #[derive(PartialEq, Clone)] 177 pub struct WasmOptions { 178 /// Enable canonicalization of all NaN values. 179 pub nan_canonicalization: Option<bool>, 180 /// Enable execution fuel with N units fuel, trapping after running out 181 /// of fuel. 182 /// 183 /// Most WebAssembly instructions consume 1 unit of fuel. Some 184 /// instructions, such as `nop`, `drop`, `block`, and `loop`, consume 0 185 /// units, as any execution cost associated with them involves other 186 /// instructions which do consume fuel. 187 pub fuel: Option<u64>, 188 /// Yield when a global epoch counter changes, allowing for async 189 /// operation without blocking the executor. 190 pub epoch_interruption: Option<bool>, 191 /// Maximum stack size, in bytes, that wasm is allowed to consume before a 192 /// stack overflow is reported. 193 pub max_wasm_stack: Option<usize>, 194 /// Allow unknown exports when running commands. 195 pub unknown_exports_allow: Option<bool>, 196 /// Allow the main module to import unknown functions, using an 197 /// implementation that immediately traps, when running commands. 198 pub unknown_imports_trap: Option<bool>, 199 /// Allow the main module to import unknown functions, using an 200 /// implementation that returns default values, when running commands. 201 pub unknown_imports_default: Option<bool>, 202 /// Enables memory error checking. (see wmemcheck.md for more info) 203 pub wmemcheck: Option<bool>, 204 /// Maximum size, in bytes, that a linear memory is allowed to reach. 205 /// 206 /// Growth beyond this limit will cause `memory.grow` instructions in 207 /// WebAssembly modules to return -1 and fail. 208 pub max_memory_size: Option<usize>, 209 /// Maximum size, in table elements, that a table is allowed to reach. 210 pub max_table_elements: Option<u32>, 211 /// Maximum number of WebAssembly instances allowed to be created. 212 pub max_instances: Option<usize>, 213 /// Maximum number of WebAssembly tables allowed to be created. 214 pub max_tables: Option<usize>, 215 /// Maximum number of WebAssembly linear memories allowed to be created. 216 pub max_memories: Option<usize>, 217 /// Force a trap to be raised on `memory.grow` and `table.grow` failure 218 /// instead of returning -1 from these instructions. 219 /// 220 /// This is not necessarily a spec-compliant option to enable but can be 221 /// useful for tracking down a backtrace of what is requesting so much 222 /// memory, for example. 223 pub trap_on_grow_failure: Option<bool>, 224 /// Maximum execution time of wasm code before timing out (1, 2s, 100ms, etc) 225 pub timeout: Option<Duration>, 226 /// Configures support for all WebAssembly proposals implemented. 227 pub all_proposals: Option<bool>, 228 /// Configure support for the bulk memory proposal. 229 pub bulk_memory: Option<bool>, 230 /// Configure support for the multi-memory proposal. 231 pub multi_memory: Option<bool>, 232 /// Configure support for the multi-value proposal. 233 pub multi_value: Option<bool>, 234 /// Configure support for the reference-types proposal. 235 pub reference_types: Option<bool>, 236 /// Configure support for the simd proposal. 237 pub simd: Option<bool>, 238 /// Configure support for the relaxed-simd proposal. 239 pub relaxed_simd: Option<bool>, 240 /// Configure forcing deterministic and host-independent behavior of 241 /// the relaxed-simd instructions. 242 /// 243 /// By default these instructions may have architecture-specific behavior as 244 /// allowed by the specification, but this can be used to force the behavior 245 /// of these instructions to match the deterministic behavior classified in 246 /// the specification. Note that enabling this option may come at a 247 /// performance cost. 248 pub relaxed_simd_deterministic: Option<bool>, 249 /// Configure support for the tail-call proposal. 250 pub tail_call: Option<bool>, 251 /// Configure support for the threads proposal. 252 pub threads: Option<bool>, 253 /// Configure support for the memory64 proposal. 254 pub memory64: Option<bool>, 255 /// Configure support for the component-model proposal. 256 pub component_model: Option<bool>, 257 /// Configure support for the function-references proposal. 258 pub function_references: Option<bool>, 259 /// Configure support for the GC proposal. 260 pub gc: Option<bool>, 261 } 262 263 enum Wasm { 264 ... 265 } 266 } 267 268 wasmtime_option_group! { 269 #[derive(PartialEq, Clone)] 270 pub struct WasiOptions { 271 /// Enable support for WASI CLI APIs, including filesystems, sockets, clocks, and random. 272 pub cli: Option<bool>, 273 /// Deprecated alias for `cli` 274 pub common: Option<bool>, 275 /// Enable support for WASI neural network API (experimental) 276 pub nn: Option<bool>, 277 /// Enable support for WASI threading API (experimental) 278 pub threads: Option<bool>, 279 /// Enable support for WASI HTTP API (experimental) 280 pub http: Option<bool>, 281 /// Inherit environment variables and file descriptors following the 282 /// systemd listen fd specification (UNIX only) 283 pub listenfd: Option<bool>, 284 /// Grant access to the given TCP listen socket 285 pub tcplisten: Vec<String>, 286 /// Implement WASI CLI APIs with preview2 primitives (experimental). 287 /// 288 /// Indicates that the implementation of WASI preview1 should be backed by 289 /// the preview2 implementation for components. 290 /// 291 /// This will become the default in the future and this option will be 292 /// removed. For now this is primarily here for testing. 293 pub preview2: Option<bool>, 294 /// Pre-load machine learning graphs (i.e., models) for use by wasi-nn. 295 /// 296 /// Each use of the flag will preload a ML model from the host directory 297 /// using the given model encoding. The model will be mapped to the 298 /// directory name: e.g., `--wasi-nn-graph openvino:/foo/bar` will preload 299 /// an OpenVINO model named `bar`. Note that which model encodings are 300 /// available is dependent on the backends implemented in the 301 /// `wasmtime_wasi_nn` crate. 302 pub nn_graph: Vec<WasiNnGraph>, 303 /// Flag for WASI preview2 to inherit the host's network within the 304 /// guest so it has full access to all addresses/ports/etc. 305 pub inherit_network: Option<bool>, 306 /// Indicates whether `wasi:sockets/ip-name-lookup` is enabled or not. 307 pub allow_ip_name_lookup: Option<bool>, 308 /// Indicates whether `wasi:sockets` TCP support is enabled or not. 309 pub tcp: Option<bool>, 310 /// Indicates whether `wasi:sockets` UDP support is enabled or not. 311 pub udp: Option<bool>, 312 /// Allows imports from the `wasi_unstable` core wasm module. 313 pub preview0: Option<bool>, 314 /// Inherit all environment variables from the parent process. 315 /// 316 /// This option can be further overwritten with `--env` flags. 317 pub inherit_env: Option<bool>, 318 } 319 320 enum Wasi { 321 ... 322 } 323 } 324 325 #[derive(Debug, Clone, PartialEq)] 326 pub struct WasiNnGraph { 327 pub format: String, 328 pub dir: String, 329 } 330 331 /// Common options for commands that translate WebAssembly modules 332 #[derive(Parser, Clone)] 333 pub struct CommonOptions { 334 // These options groups are used to parse `-O` and such options but aren't 335 // the raw form consumed by the CLI. Instead they're pushed into the `pub` 336 // fields below as part of the `configure` method. 337 // 338 // Ideally clap would support `pub opts: OptimizeOptions` and parse directly 339 // into that but it does not appear to do so for multiple `-O` flags for 340 // now. 341 /// Optimization and tuning related options for wasm performance, `-O help` to 342 /// see all. 343 #[arg(short = 'O', long = "optimize", value_name = "KEY[=VAL[,..]]")] 344 opts_raw: Vec<opt::CommaSeparated<Optimize>>, 345 346 /// Codegen-related configuration options, `-C help` to see all. 347 #[arg(short = 'C', long = "codegen", value_name = "KEY[=VAL[,..]]")] 348 codegen_raw: Vec<opt::CommaSeparated<Codegen>>, 349 350 /// Debug-related configuration options, `-D help` to see all. 351 #[arg(short = 'D', long = "debug", value_name = "KEY[=VAL[,..]]")] 352 debug_raw: Vec<opt::CommaSeparated<Debug>>, 353 354 /// Options for configuring semantic execution of WebAssembly, `-W help` to see 355 /// all. 356 #[arg(short = 'W', long = "wasm", value_name = "KEY[=VAL[,..]]")] 357 wasm_raw: Vec<opt::CommaSeparated<Wasm>>, 358 359 /// Options for configuring WASI and its proposals, `-S help` to see all. 360 #[arg(short = 'S', long = "wasi", value_name = "KEY[=VAL[,..]]")] 361 wasi_raw: Vec<opt::CommaSeparated<Wasi>>, 362 363 // These fields are filled in by the `configure` method below via the 364 // options parsed from the CLI above. This is what the CLI should use. 365 #[arg(skip)] 366 configured: bool, 367 #[arg(skip)] 368 pub opts: OptimizeOptions, 369 #[arg(skip)] 370 pub codegen: CodegenOptions, 371 #[arg(skip)] 372 pub debug: DebugOptions, 373 #[arg(skip)] 374 pub wasm: WasmOptions, 375 #[arg(skip)] 376 pub wasi: WasiOptions, 377 } 378 379 macro_rules! match_feature { 380 ( 381 [$feat:tt : $config:expr] 382 $val:ident => $e:expr, 383 $p:pat => err, 384 ) => { 385 #[cfg(feature = $feat)] 386 { 387 if let Some($val) = $config { 388 $e; 389 } 390 } 391 #[cfg(not(feature = $feat))] 392 { 393 if let Some($p) = $config { 394 anyhow::bail!(concat!("support for ", $feat, " disabled at compile time")); 395 } 396 } 397 }; 398 } 399 400 impl CommonOptions { 401 fn configure(&mut self) { 402 if self.configured { 403 return; 404 } 405 self.configured = true; 406 self.opts.configure_with(&self.opts_raw); 407 self.codegen.configure_with(&self.codegen_raw); 408 self.debug.configure_with(&self.debug_raw); 409 self.wasm.configure_with(&self.wasm_raw); 410 self.wasi.configure_with(&self.wasi_raw); 411 } 412 413 pub fn init_logging(&mut self) -> Result<()> { 414 self.configure(); 415 if self.debug.logging == Some(false) { 416 return Ok(()); 417 } 418 #[cfg(feature = "logging")] 419 if self.debug.log_to_files == Some(true) { 420 let prefix = "wasmtime.dbg."; 421 init_file_per_thread_logger(prefix); 422 } else { 423 use std::io::IsTerminal; 424 use tracing_subscriber::{EnvFilter, FmtSubscriber}; 425 let b = FmtSubscriber::builder() 426 .with_writer(std::io::stderr) 427 .with_env_filter(EnvFilter::from_env("WASMTIME_LOG")) 428 .with_ansi(std::io::stderr().is_terminal()); 429 b.init(); 430 } 431 #[cfg(not(feature = "logging"))] 432 if self.debug.log_to_files == Some(true) || self.debug.logging == Some(true) { 433 anyhow::bail!("support for logging disabled at compile time"); 434 } 435 Ok(()) 436 } 437 438 pub fn config( 439 &mut self, 440 target: Option<&str>, 441 pooling_allocator_default: Option<bool>, 442 ) -> Result<Config> { 443 self.configure(); 444 let mut config = Config::new(); 445 446 match_feature! { 447 ["cranelift" : self.codegen.compiler] 448 strategy => config.strategy(strategy), 449 _ => err, 450 } 451 match_feature! { 452 ["cranelift" : target] 453 target => config.target(target)?, 454 _ => err, 455 } 456 match_feature! { 457 ["cranelift" : self.codegen.cranelift_debug_verifier] 458 enable => config.cranelift_debug_verifier(enable), 459 true => err, 460 } 461 if let Some(enable) = self.debug.debug_info { 462 config.debug_info(enable); 463 } 464 if self.debug.coredump.is_some() { 465 #[cfg(feature = "coredump")] 466 config.coredump_on_trap(true); 467 #[cfg(not(feature = "coredump"))] 468 anyhow::bail!("support for coredumps disabled at compile time"); 469 } 470 match_feature! { 471 ["cranelift" : self.opts.opt_level] 472 level => config.cranelift_opt_level(level), 473 _ => err, 474 } 475 match_feature! { 476 ["cranelift" : self.wasm.nan_canonicalization] 477 enable => config.cranelift_nan_canonicalization(enable), 478 true => err, 479 } 480 match_feature! { 481 ["cranelift" : self.codegen.pcc] 482 enable => config.cranelift_pcc(enable), 483 true => err, 484 } 485 486 self.enable_wasm_features(&mut config)?; 487 488 #[cfg(feature = "cranelift")] 489 for (name, value) in self.codegen.cranelift.iter() { 490 let name = name.replace('-', "_"); 491 unsafe { 492 match value { 493 Some(val) => { 494 config.cranelift_flag_set(&name, val); 495 } 496 None => { 497 config.cranelift_flag_enable(&name); 498 } 499 } 500 } 501 } 502 #[cfg(not(feature = "cranelift"))] 503 if !self.codegen.cranelift.is_empty() { 504 anyhow::bail!("support for cranelift disabled at compile time"); 505 } 506 507 #[cfg(feature = "cache")] 508 if self.codegen.cache != Some(false) { 509 match &self.codegen.cache_config { 510 Some(path) => { 511 config.cache_config_load(path)?; 512 } 513 None => { 514 config.cache_config_load_default()?; 515 } 516 } 517 } 518 #[cfg(not(feature = "cache"))] 519 if self.codegen.cache == Some(true) { 520 anyhow::bail!("support for caching disabled at compile time"); 521 } 522 523 match_feature! { 524 ["parallel-compilation" : self.codegen.parallel_compilation] 525 enable => config.parallel_compilation(enable), 526 true => err, 527 } 528 529 if let Some(max) = self.opts.static_memory_maximum_size { 530 config.static_memory_maximum_size(max); 531 } 532 533 if let Some(enable) = self.opts.static_memory_forced { 534 config.static_memory_forced(enable); 535 } 536 537 if let Some(size) = self.opts.static_memory_guard_size { 538 config.static_memory_guard_size(size); 539 } 540 541 if let Some(size) = self.opts.dynamic_memory_guard_size { 542 config.dynamic_memory_guard_size(size); 543 } 544 if let Some(size) = self.opts.dynamic_memory_reserved_for_growth { 545 config.dynamic_memory_reserved_for_growth(size); 546 } 547 if let Some(enable) = self.opts.guard_before_linear_memory { 548 config.guard_before_linear_memory(enable); 549 } 550 if let Some(enable) = self.opts.table_lazy_init { 551 config.table_lazy_init(enable); 552 } 553 554 // If fuel has been configured, set the `consume fuel` flag on the config. 555 if self.wasm.fuel.is_some() { 556 config.consume_fuel(true); 557 } 558 559 if let Some(enable) = self.wasm.epoch_interruption { 560 config.epoch_interruption(enable); 561 } 562 if let Some(enable) = self.debug.address_map { 563 config.generate_address_map(enable); 564 } 565 if let Some(enable) = self.opts.memory_init_cow { 566 config.memory_init_cow(enable); 567 } 568 569 match_feature! { 570 ["pooling-allocator" : self.opts.pooling_allocator.or(pooling_allocator_default)] 571 enable => { 572 if enable { 573 let mut cfg = wasmtime::PoolingAllocationConfig::default(); 574 if let Some(size) = self.opts.pooling_memory_keep_resident { 575 cfg.linear_memory_keep_resident(size); 576 } 577 if let Some(size) = self.opts.pooling_table_keep_resident { 578 cfg.table_keep_resident(size); 579 } 580 if let Some(limit) = self.opts.pooling_total_core_instances { 581 cfg.total_core_instances(limit); 582 } 583 if let Some(limit) = self.opts.pooling_total_component_instances { 584 cfg.total_component_instances(limit); 585 } 586 if let Some(limit) = self.opts.pooling_total_memories { 587 cfg.total_memories(limit); 588 } 589 if let Some(limit) = self.opts.pooling_total_tables { 590 cfg.total_tables(limit); 591 } 592 match_feature! { 593 ["async" : self.opts.pooling_total_stacks] 594 limit => cfg.total_stacks(limit), 595 _ => err, 596 } 597 if let Some(limit) = self.opts.pooling_max_memory_size { 598 cfg.max_memory_size(limit); 599 } 600 match_feature! { 601 ["memory-protection-keys" : self.opts.memory_protection_keys] 602 enable => cfg.memory_protection_keys(if enable { 603 wasmtime::MpkEnabled::Enable 604 } else { 605 wasmtime::MpkEnabled::Disable 606 }), 607 _ => err, 608 } 609 config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(cfg)); 610 } 611 }, 612 true => err, 613 } 614 615 if self.opts.memory_protection_keys.unwrap_or(false) 616 && !self.opts.pooling_allocator.unwrap_or(false) 617 { 618 anyhow::bail!("memory protection keys require the pooling allocator"); 619 } 620 621 if let Some(max) = self.wasm.max_wasm_stack { 622 config.max_wasm_stack(max); 623 } 624 625 if let Some(enable) = self.wasm.relaxed_simd_deterministic { 626 config.relaxed_simd_deterministic(enable); 627 } 628 match_feature! { 629 ["cranelift" : self.wasm.wmemcheck] 630 enable => config.wmemcheck(enable), 631 true => err, 632 } 633 634 Ok(config) 635 } 636 637 pub fn enable_wasm_features(&self, config: &mut Config) -> Result<()> { 638 let all = self.wasm.all_proposals; 639 640 if let Some(enable) = self.wasm.simd.or(all) { 641 config.wasm_simd(enable); 642 } 643 if let Some(enable) = self.wasm.relaxed_simd.or(all) { 644 config.wasm_relaxed_simd(enable); 645 } 646 if let Some(enable) = self.wasm.bulk_memory.or(all) { 647 config.wasm_bulk_memory(enable); 648 } 649 if let Some(enable) = self.wasm.multi_value.or(all) { 650 config.wasm_multi_value(enable); 651 } 652 if let Some(enable) = self.wasm.tail_call.or(all) { 653 config.wasm_tail_call(enable); 654 } 655 if let Some(enable) = self.wasm.multi_memory.or(all) { 656 config.wasm_multi_memory(enable); 657 } 658 if let Some(enable) = self.wasm.memory64.or(all) { 659 config.wasm_memory64(enable); 660 } 661 662 macro_rules! handle_conditionally_compiled { 663 ($(($feature:tt, $field:tt, $method:tt))*) => ($( 664 if let Some(enable) = self.wasm.$field.or(all) { 665 #[cfg(feature = $feature)] 666 config.$method(enable); 667 #[cfg(not(feature = $feature))] 668 if enable && all.is_none() { 669 anyhow::bail!("support for {} was disabled at compile-time", $feature); 670 } 671 } 672 )*) 673 } 674 675 handle_conditionally_compiled! { 676 ("component-model", component_model, wasm_component_model) 677 ("threads", threads, wasm_threads) 678 ("gc", gc, wasm_gc) 679 ("gc", reference_types, wasm_reference_types) 680 ("gc", function_references, wasm_function_references) 681 } 682 Ok(()) 683 } 684 } 685 686 impl PartialEq for CommonOptions { 687 fn eq(&self, other: &CommonOptions) -> bool { 688 let mut me = self.clone(); 689 me.configure(); 690 let mut other = other.clone(); 691 other.configure(); 692 let CommonOptions { 693 opts_raw: _, 694 codegen_raw: _, 695 debug_raw: _, 696 wasm_raw: _, 697 wasi_raw: _, 698 configured: _, 699 700 opts, 701 codegen, 702 debug, 703 wasm, 704 wasi, 705 } = me; 706 opts == other.opts 707 && codegen == other.codegen 708 && debug == other.debug 709 && wasm == other.wasm 710 && wasi == other.wasi 711 } 712 } 713