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