Merge with upstream

.github/actions/install-rust/action.yml

@@ -9,7 +9,7 @@ inputs:
   msrv_range:
     description: 'Versions later-than-latest-Rust the MSRV supports'
     required: false
-    default: '1'
+    default: '2'
 
 runs:
   using: composite
@@ -28,7 +28,7 @@ runs:
         elif [ "${{ inputs.toolchain }}" = "msrv" ]; then
           echo "version=1.$msrv.0" >> "$GITHUB_OUTPUT"
         elif [ "${{ inputs.toolchain }}" = "wasmtime-ci-pinned-nightly" ]; then
-          echo "version=nightly-2025-04-03" >> "$GITHUB_OUTPUT"
+          echo "version=nightly-2025-05-16" >> "$GITHUB_OUTPUT"
         else
           echo "version=${{ inputs.toolchain }}" >> "$GITHUB_OUTPUT"
         fi

.github/workflows/main.yml

@@ -812,8 +812,15 @@ jobs:
       if: matrix.filter == 'linux-x64' && contains(matrix.bucket, 'wasmtime-cli')
       uses: abrown/install-vtune-action@v1
 
-    # Build and test all features
-    - run: ./ci/run-tests.sh --locked ${{ matrix.bucket }}
+    # Build and test all features.
+    #
+    # Note that this uses a different shell, notably not `bash` on Windows. In
+    # the past `bash` would add more items to `PATH` on Windows which would
+    # interfere and cause the `gcc.exe` executable to fail and exit with 1 and
+    # no output. It's believed that `bash` adds things like `/usr/bin` to PATH
+    # which is the wrong DLL or something like that.
+    - run: python3 ./ci/run-tests.py --locked ${{ matrix.bucket }}
+      shell: pwsh
 
     # common logic to cancel the entire run if this job fails
     - uses: ./.github/actions/cancel-on-failure

Cargo.toml

@@ -173,7 +173,7 @@ exclude = [
 [workspace.package]
 version = "34.0.0"
 authors = ["The Wasmtime Project Developers"]
-edition = "2021"
+edition = "2024"
 # Wasmtime's current policy is that this number can be no larger than the
 # current stable release of Rust minus 2.
 rust-version = "1.85.0"
@@ -187,19 +187,6 @@ unused_import_braces = 'warn'
 unused-lifetimes = 'warn'
 unused-macro-rules = 'warn'
 
-# Lints that are part of the `rust-2024-compatibility` group. This group is a
-# bit too noisy to enable wholesale but some selective items are ones we want to
-# opt-in to.
-keyword_idents_2024 = 'warn'
-unsafe-attr-outside-unsafe = 'warn'
-deprecated-safe-2024 = 'warn'
-rust-2024-guarded-string-incompatible-syntax = 'warn'
-rust-2024-prelude-collisions = 'warn'
-rust-2024-incompatible-pat = 'warn'
-missing-unsafe-on-extern = 'warn'
-impl-trait-overcaptures = 'warn'
-unsafe-op-in-unsafe-fn = 'warn'
-
 # Don't warn about unknown cfgs for pulley
 [workspace.lints.rust.unexpected_cfgs]
 level = "warn"
@@ -292,7 +279,7 @@ byte-array-literals = { path = "crates/wasi-preview1-component-adapter/byte-arra
 
 # Bytecode Alliance maintained dependencies:
 # ---------------------------
-regalloc2 = "0.12.1"
+regalloc2 = "0.12.2"
 
 # cap-std family:
 target-lexicon = "0.13.0"
@@ -309,8 +296,8 @@ io-extras = "0.18.1"
 rustix = "1.0.3"
 # wit-bindgen:
 wit-bindgen = { version = "0.42.1", default-features = false }
-wit-bindgen-rust-macro = { version = "0.42.1", default-features = false }
 wit-bindgen-rt = { version = "0.42.1", default-features = false }
+wit-bindgen-rust-macro = { version = "0.42.1", default-features = false }
 
 # wasm-tools family:
 wasmparser = { version = "0.230.0", default-features = false, features = ['simd'] }

benches/call.rs

@@ -1,5 +1,5 @@
 use criterion::measurement::WallTime;
-use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion};
+use criterion::{BenchmarkGroup, Criterion, criterion_group, criterion_main};
 use std::fmt::Debug;
 use std::future::Future;
 use std::pin::Pin;

benches/instantiation.rs

@@ -1,12 +1,12 @@
 use anyhow::Result;
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use std::cell::LazyCell;
 use std::path::Path;
 use std::process::Command;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::thread;
-use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
+use wasi_common::{WasiCtx, sync::WasiCtxBuilder};
 use wasmtime::*;
 
 fn store(engine: &Engine) -> Store<WasiCtx> {

benches/thread_eager_init.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use std::thread;
 use std::time::{Duration, Instant};
 use wasmtime::*;

benches/wasi.rs

@@ -1,8 +1,8 @@
 //! Measure some common WASI call scenarios.
 
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use std::{fs::File, path::Path, time::Instant};
-use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
+use wasi_common::{WasiCtx, sync::WasiCtxBuilder};
 use wasmtime::{Engine, Linker, Module, Store, TypedFunc};
 
 criterion_group!(benches, bench_wasi);

ci/build-test-matrix.js

@@ -95,14 +95,12 @@ const FULL_MATRIX = [
     "name": "Test Windows MSVC x86_64",
     "filter": "windows-x64",
   },
-  // FIXME: As of this writing, some of the GitHub images have a broken MinGW,
-  // leading CI to fail nondeterministically.
-  // {
-  //   "os": windows,
-  //   "target": "x86_64-pc-windows-gnu",
-  //   "name": "Test Windows MinGW x86_64",
-  //   "filter": "mingw-x64"
-  // },
+  {
+    "os": windows,
+    "target": "x86_64-pc-windows-gnu",
+    "name": "Test Windows MinGW x86_64",
+    "filter": "mingw-x64"
+  },
   {
     "os": ubuntu + '-arm',
     "target": "aarch64-unknown-linux-gnu",

ci/run-tests.sh → ci/run-tests.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env python3
 
 # Excludes:
 #
@@ -15,12 +15,16 @@
 #
 # - veri_engine: requires an SMT solver (z3)
 
-cargo test \
-      --workspace \
-      --all-features \
-      --exclude test-programs \
-      --exclude wasmtime-wasi-nn \
-      --exclude wasmtime-fuzzing \
-      --exclude wasm-spec-interpreter \
-      --exclude veri_engine \
-      $@
+import subprocess
+import sys
+
+args = ['cargo', 'test', '--workspace', '--all-features']
+args.append('--exclude=test-programs')
+args.append('--exclude=wasmtime-wasi-nn')
+args.append('--exclude=wasmtime-fuzzing')
+args.append('--exclude=wasm-spec-interpreter')
+args.append('--exclude=veri_engine')
+args.extend(sys.argv[1:])
+
+result = subprocess.run(args)
+sys.exit(result.returncode)

cranelift/assembler-x64/fuzz/fuzz_targets/roundtrip.rs

@@ -1,6 +1,6 @@
 #![no_main]
 
-use cranelift_assembler_x64::{fuzz, Inst};
+use cranelift_assembler_x64::{Inst, fuzz};
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|inst: Inst<fuzz::FuzzRegs>| {

cranelift/assembler-x64/meta/src/dsl.rs

@@ -8,11 +8,13 @@ mod encoding;
 mod features;
 pub mod format;
 
+pub use encoding::{
+    Encoding, Group1Prefix, Group2Prefix, Group3Prefix, Group4Prefix, Opcodes, Prefixes, Rex,
+};
 pub use encoding::{rex, vex};
-pub use encoding::{Encoding, Group1Prefix, Group2Prefix, Group3Prefix, Group4Prefix, Opcodes, Prefixes, Rex};
-pub use features::{Feature, Features, ALL_FEATURES};
-pub use format::{align, fmt, r, rw, sxl, sxq, sxw};
+pub use features::{ALL_FEATURES, Feature, Features};
 pub use format::{Extension, Format, Location, Mutability, Operand, OperandKind};
+pub use format::{align, fmt, r, rw, sxl, sxq, sxw, w};
 
 /// Abbreviated constructor for an x64 instruction.
 pub fn inst(
@@ -69,13 +71,22 @@ impl Inst {
     /// the format name (e.g., `sx*`) to keep this unique.
     #[must_use]
     pub fn name(&self) -> String {
-        format!("{}_{}", self.mnemonic.to_lowercase(), self.format.name.to_lowercase())
+        format!(
+            "{}_{}",
+            self.mnemonic.to_lowercase(),
+            self.format.name.to_lowercase()
+        )
     }
 }
 
 impl core::fmt::Display for Inst {
     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
-        let Inst { mnemonic: name, format, encoding, features } = self;
+        let Inst {
+            mnemonic: name,
+            format,
+            encoding,
+            features,
+        } = self;
         write!(f, "{name}: {format} => {encoding}")?;
         if !features.is_empty() {
             write!(f, " [{features}]")?;

cranelift/assembler-x64/meta/src/dsl/encoding.rs

@@ -124,7 +124,10 @@ impl Rex {
     #[must_use]
     pub fn digit(self, digit: u8) -> Self {
         assert!(digit <= 0b111, "must fit in 3 bits");
-        Self { digit: Some(digit), ..self }
+        Self {
+            digit: Some(digit),
+            ..self
+        }
     }
 
     /// Append a byte-sized immediate operand (8-bit); equivalent to `ib` in the
@@ -136,7 +139,10 @@ impl Rex {
     #[must_use]
     pub fn ib(self) -> Self {
         assert_eq!(self.imm, Imm::None);
-        Self { imm: Imm::ib, ..self }
+        Self {
+            imm: Imm::ib,
+            ..self
+        }
     }
 
     /// Append a word-sized immediate operand (16-bit); equivalent to `iw` in
@@ -148,7 +154,10 @@ impl Rex {
     #[must_use]
     pub fn iw(self) -> Self {
         assert_eq!(self.imm, Imm::None);
-        Self { imm: Imm::iw, ..self }
+        Self {
+            imm: Imm::iw,
+            ..self
+        }
     }
 
     /// Append a doubleword-sized immediate operand (32-bit); equivalent to `id`
@@ -160,7 +169,10 @@ impl Rex {
     #[must_use]
     pub fn id(self) -> Self {
         assert_eq!(self.imm, Imm::None);
-        Self { imm: Imm::id, ..self }
+        Self {
+            imm: Imm::id,
+            ..self
+        }
     }
 
     /// Append a quadword-sized immediate operand (64-bit); equivalent to `io`
@@ -172,7 +184,10 @@ impl Rex {
     #[must_use]
     pub fn io(self) -> Self {
         assert_eq!(self.imm, Imm::None);
-        Self { imm: Imm::io, ..self }
+        Self {
+            imm: Imm::io,
+            ..self
+        }
     }
 
     /// Check a subset of the rules for valid encodings outlined in chapter 2,
@@ -188,11 +203,11 @@ impl Rex {
 
         if self.opcodes.prefixes.has_operand_size_override() {
             assert!(
-                operands
-                    .iter()
-                    .all(|&op| matches!(op.location.kind(), OperandKind::Imm(_) | OperandKind::FixedReg(_))
-                        || op.location.bits() == 16
-                        || op.location.bits() == 128),
+                operands.iter().all(|&op| matches!(
+                    op.location.kind(),
+                    OperandKind::Imm(_) | OperandKind::FixedReg(_)
+                ) || op.location.bits() == 16
+                    || op.location.bits() == 128),
                 "when we encode the 66 prefix, we expect all operands to be 16-bit wide"
             );
         }
@@ -313,9 +328,16 @@ impl<const N: usize> From<[u8; N]> for Opcodes {
             [primary] => (false, *primary, None),
             [0x0f, primary] => (true, *primary, None),
             [0x0f, primary, secondary] => (true, *primary, Some(*secondary)),
-            _ => panic!("invalid opcodes after prefix; expected [opcode], [0x0f, opcode], or [0x0f, opcode, opcode], found {remaining:?}"),
+            _ => panic!(
+                "invalid opcodes after prefix; expected [opcode], [0x0f, opcode], or [0x0f, opcode, opcode], found {remaining:?}"
+            ),
         };
-        Self { prefixes, escape, primary, secondary }
+        Self {
+            prefixes,
+            escape,
+            primary,
+            secondary,
+        }
     }
 }
 
@@ -381,7 +403,10 @@ impl Prefixes {
 
     /// Check if any prefix is present.
     pub fn is_empty(&self) -> bool {
-        self.group1.is_none() && self.group2.is_none() && self.group3.is_none() && self.group4.is_none()
+        self.group1.is_none()
+            && self.group2.is_none()
+            && self.group3.is_none()
+            && self.group4.is_none()
     }
 }