diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index 22c833a5488fa..b9441236bcd3e 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -12,6 +12,9 @@ on:
   schedule:
     - cron: '44 4 * * *' # At 4:44 UTC every day.
 
+permissions:
+  contents: write
+
 defaults:
   run:
     shell: bash
diff --git a/src/tools/miri/miri-script/src/args.rs b/src/tools/miri/miri-script/src/args.rs
index 16a21757b3535..c1688ca0fb6b2 100644
--- a/src/tools/miri/miri-script/src/args.rs
+++ b/src/tools/miri/miri-script/src/args.rs
@@ -1,7 +1,7 @@
 use std::env;
 use std::iter;
 
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 
 pub struct Args {
     args: iter::Peekable<env::Args>,
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index b18c8453d661e..b0e62d5cda6f0 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -8,13 +8,13 @@ use std::path::PathBuf;
 use std::process;
 use std::time::Duration;
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use path_macro::path;
 use walkdir::WalkDir;
-use xshell::{cmd, Shell};
+use xshell::{Shell, cmd};
 
-use crate::util::*;
 use crate::Command;
+use crate::util::*;
 
 /// Used for rustc syncs.
 const JOSH_FILTER: &str =
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index 9214823710709..0620f3aaf0993 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -6,7 +6,7 @@ mod util;
 
 use std::ops::Range;
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 
 #[derive(Clone, Debug)]
 pub enum Command {
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index 9d1a8e4fb1d5b..f5a6a8188a0dc 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -5,10 +5,10 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::{env, iter, thread};
 
-use anyhow::{anyhow, bail, Context, Result};
+use anyhow::{Context, Result, anyhow, bail};
 use dunce::canonicalize;
 use path_macro::path;
-use xshell::{cmd, Cmd, Shell};
+use xshell::{Cmd, Shell, cmd};
 
 pub fn miri_dir() -> std::io::Result<PathBuf> {
     const MIRI_SCRIPT_ROOT_DIR: &str = env!("CARGO_MANIFEST_DIR");
diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 3f4d095fc1961..76fe17316ac65 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-e2dc1a1c0f97a90319181a721ab317210307617a
+6ce376774c0bc46ac8be247bca93ff5a1287a8fc
diff --git a/src/tools/miri/rustfmt.toml b/src/tools/miri/rustfmt.toml
index be5af7379eae7..3f9311d9d1a50 100644
--- a/src/tools/miri/rustfmt.toml
+++ b/src/tools/miri/rustfmt.toml
@@ -1,4 +1,4 @@
-version = "Two"
+style_edition = "2024"
 use_small_heuristics = "Max"
 match_arm_blocks = false
 match_arm_leading_pipes = "Preserve"
diff --git a/src/tools/miri/src/alloc_addresses/reuse_pool.rs b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
index 77fc9f53f9e37..f6c1675634460 100644
--- a/src/tools/miri/src/alloc_addresses/reuse_pool.rs
+++ b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
@@ -4,7 +4,7 @@ use rand::Rng;
 
 use rustc_target::abi::{Align, Size};
 
-use crate::{concurrency::VClock, MemoryKind, MiriConfig, ThreadId};
+use crate::{MemoryKind, MiriConfig, ThreadId, concurrency::VClock};
 
 const MAX_POOL_SIZE: usize = 64;
 
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index fc2b3f9c6ea77..e7d7cc28eeee6 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -12,12 +12,12 @@ use std::mem;
 
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::mir::{Mutability, RetagKind};
-use rustc_middle::ty::{self, layout::HasParamEnv, Ty};
+use rustc_middle::ty::{self, Ty, layout::HasParamEnv};
 use rustc_target::abi::{Abi, Size};
 
 use crate::borrow_tracker::{
-    stacked_borrows::diagnostics::{AllocHistory, DiagnosticCx, DiagnosticCxBuilder},
     GlobalStateInner, ProtectorKind,
+    stacked_borrows::diagnostics::{AllocHistory, DiagnosticCx, DiagnosticCxBuilder},
 };
 use crate::concurrency::data_race::{NaReadType, NaWriteType};
 use crate::*;
@@ -913,11 +913,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 new_perm: NewPermission,
             ) -> InterpResult<'tcx> {
                 let val = self.ecx.read_immediate(&self.ecx.place_to_op(place)?)?;
-                let val = self.ecx.sb_retag_reference(
-                    &val,
-                    new_perm,
-                    RetagInfo { cause: self.retag_cause, in_field: self.in_field },
-                )?;
+                let val = self.ecx.sb_retag_reference(&val, new_perm, RetagInfo {
+                    cause: self.retag_cause,
+                    in_field: self.in_field,
+                })?;
                 self.ecx.write_immediate(*val, place)?;
                 Ok(())
             }
@@ -1003,11 +1002,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             access: Some(AccessKind::Write),
             protector: Some(ProtectorKind::StrongProtector),
         };
-        this.sb_retag_place(
-            place,
-            new_perm,
-            RetagInfo { cause: RetagCause::InPlaceFnPassing, in_field: false },
-        )
+        this.sb_retag_place(place, new_perm, RetagInfo {
+            cause: RetagCause::InPlaceFnPassing,
+            in_field: false,
+        })
     }
 
     /// Mark the given tag as exposed. It was found on a pointer with the given AllocId.
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
index 774b36919fe34..5c040983142f8 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/stack.rs
@@ -4,11 +4,11 @@ use std::ops::Range;
 use rustc_data_structures::fx::FxHashSet;
 use tracing::trace;
 
+use crate::ProvenanceExtra;
 use crate::borrow_tracker::{
-    stacked_borrows::{Item, Permission},
     AccessKind, BorTag,
+    stacked_borrows::{Item, Permission},
 };
-use crate::ProvenanceExtra;
 
 /// Exactly what cache size we should use is a difficult trade-off. There will always be some
 /// workload which has a `BorTag` working set which exceeds the size of the cache, and ends up
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
index a753de28a041e..44ea7533b00cb 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/diagnostics.rs
@@ -4,12 +4,12 @@ use std::ops::Range;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_span::{Span, SpanData};
 
+use crate::borrow_tracker::ProtectorKind;
 use crate::borrow_tracker::tree_borrows::{
     perms::{PermTransition, Permission},
     tree::LocationState,
     unimap::UniIndex,
 };
-use crate::borrow_tracker::ProtectorKind;
 use crate::*;
 
 /// Cause of an access: either a real access or one
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 722cb79c66b10..89b8ff1af8bdb 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -1,6 +1,6 @@
 use rustc_middle::{
     mir::{Mutability, RetagKind},
-    ty::{self, layout::HasParamEnv, Ty},
+    ty::{self, Ty, layout::HasParamEnv},
 };
 use rustc_span::def_id::DefId;
 use rustc_target::abi::{Abi, Size};
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
index c29bd719b15df..dfb9b8637fde5 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
@@ -1,9 +1,9 @@
 use std::cmp::{Ordering, PartialOrd};
 use std::fmt;
 
+use crate::AccessKind;
 use crate::borrow_tracker::tree_borrows::diagnostics::TransitionError;
 use crate::borrow_tracker::tree_borrows::tree::AccessRelatedness;
-use crate::AccessKind;
 
 /// The activation states of a pointer.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -345,18 +345,14 @@ pub mod diagnostics {
     use super::*;
     impl fmt::Display for PermissionPriv {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            write!(
-                f,
-                "{}",
-                match self {
-                    ReservedFrz { conflicted: false } => "Reserved",
-                    ReservedFrz { conflicted: true } => "Reserved (conflicted)",
-                    ReservedIM => "Reserved (interior mutable)",
-                    Active => "Active",
-                    Frozen => "Frozen",
-                    Disabled => "Disabled",
-                }
-            )
+            write!(f, "{}", match self {
+                ReservedFrz { conflicted: false } => "Reserved",
+                ReservedFrz { conflicted: true } => "Reserved (conflicted)",
+                ReservedIM => "Reserved (interior mutable)",
+                Active => "Active",
+                Frozen => "Frozen",
+                Disabled => "Disabled",
+            })
         }
     }
 
@@ -551,7 +547,7 @@ impl Permission {
 #[cfg(test)]
 mod propagation_optimization_checks {
     pub use super::*;
-    use crate::borrow_tracker::tree_borrows::exhaustive::{precondition, Exhaustive};
+    use crate::borrow_tracker::tree_borrows::exhaustive::{Exhaustive, precondition};
 
     impl Exhaustive for PermissionPriv {
         fn exhaustive() -> Box<dyn Iterator<Item = Self>> {
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
index 53e722259fdfb..a99c71d96b4b1 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -19,10 +19,10 @@ use rustc_span::Span;
 use rustc_target::abi::Size;
 
 use crate::borrow_tracker::tree_borrows::{
+    Permission,
     diagnostics::{self, NodeDebugInfo, TbError, TransitionError},
     perms::PermTransition,
     unimap::{UniEntry, UniIndex, UniKeyMap, UniValMap},
-    Permission,
 };
 use crate::borrow_tracker::{GlobalState, ProtectorKind};
 use crate::*;
@@ -587,16 +587,13 @@ impl Tree {
             let mut debug_info = NodeDebugInfo::new(root_tag, root_default_perm, span);
             // name the root so that all allocations contain one named pointer
             debug_info.add_name("root of the allocation");
-            nodes.insert(
-                root_idx,
-                Node {
-                    tag: root_tag,
-                    parent: None,
-                    children: SmallVec::default(),
-                    default_initial_perm: root_default_perm,
-                    debug_info,
-                },
-            );
+            nodes.insert(root_idx, Node {
+                tag: root_tag,
+                parent: None,
+                children: SmallVec::default(),
+                default_initial_perm: root_default_perm,
+                debug_info,
+            });
             nodes
         };
         let rperms = {
@@ -626,16 +623,13 @@ impl<'tcx> Tree {
         let idx = self.tag_mapping.insert(new_tag);
         let parent_idx = self.tag_mapping.get(&parent_tag).unwrap();
         // Create the node
-        self.nodes.insert(
-            idx,
-            Node {
-                tag: new_tag,
-                parent: Some(parent_idx),
-                children: SmallVec::default(),
-                default_initial_perm,
-                debug_info: NodeDebugInfo::new(new_tag, default_initial_perm, span),
-            },
-        );
+        self.nodes.insert(idx, Node {
+            tag: new_tag,
+            parent: Some(parent_idx),
+            children: SmallVec::default(),
+            default_initial_perm,
+            debug_info: NodeDebugInfo::new(new_tag, default_initial_perm, span),
+        });
         // Register new_tag as a child of parent_tag
         self.nodes.get_mut(parent_idx).unwrap().children.push(idx);
         // Initialize perms
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
index f64f7bf8e8c1e..5cd5040f80776 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
@@ -2,7 +2,7 @@
 #![cfg(test)]
 
 use super::*;
-use crate::borrow_tracker::tree_borrows::exhaustive::{precondition, Exhaustive};
+use crate::borrow_tracker::tree_borrows::exhaustive::{Exhaustive, precondition};
 use std::fmt;
 
 impl Exhaustive for LocationState {
diff --git a/src/tools/miri/src/concurrency/sync.rs b/src/tools/miri/src/concurrency/sync.rs
index 1f910d885ca5a..bc4d805687268 100644
--- a/src/tools/miri/src/concurrency/sync.rs
+++ b/src/tools/miri/src/concurrency/sync.rs
@@ -1,5 +1,5 @@
 use std::any::Any;
-use std::collections::{hash_map::Entry, VecDeque};
+use std::collections::{VecDeque, hash_map::Entry};
 use std::ops::Not;
 use std::time::Duration;
 
@@ -283,12 +283,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         data: Option<Box<dyn Any>>,
     ) -> InterpResult<'tcx, MutexId> {
         let this = self.eval_context_mut();
-        this.create_id(
-            lock,
-            offset,
-            |ecx| &mut ecx.machine.sync.mutexes,
-            Mutex { data, ..Default::default() },
-        )
+        this.create_id(lock, offset, |ecx| &mut ecx.machine.sync.mutexes, Mutex {
+            data,
+            ..Default::default()
+        })
     }
 
     /// Lazily create a new mutex.
@@ -355,12 +353,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         data: Option<Box<dyn Any>>,
     ) -> InterpResult<'tcx, CondvarId> {
         let this = self.eval_context_mut();
-        this.create_id(
-            condvar,
-            offset,
-            |ecx| &mut ecx.machine.sync.condvars,
-            Condvar { data, ..Default::default() },
-        )
+        this.create_id(condvar, offset, |ecx| &mut ecx.machine.sync.condvars, Condvar {
+            data,
+            ..Default::default()
+        })
     }
 
     fn condvar_get_or_create_id(
diff --git a/src/tools/miri/src/concurrency/vector_clock.rs b/src/tools/miri/src/concurrency/vector_clock.rs
index 0968e10bbee0b..901b097c1bd77 100644
--- a/src/tools/miri/src/concurrency/vector_clock.rs
+++ b/src/tools/miri/src/concurrency/vector_clock.rs
@@ -1,5 +1,5 @@
 use rustc_index::Idx;
-use rustc_span::{Span, SpanData, DUMMY_SP};
+use rustc_span::{DUMMY_SP, Span, SpanData};
 use smallvec::SmallVec;
 use std::{
     cmp::Ordering,
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 92f344d13b72c..4445550512b49 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -2,7 +2,7 @@ use std::fmt::{self, Write};
 use std::num::NonZero;
 
 use rustc_errors::{Diag, DiagMessage, Level};
-use rustc_span::{SpanData, Symbol, DUMMY_SP};
+use rustc_span::{DUMMY_SP, SpanData, Symbol};
 use rustc_target::abi::{Align, Size};
 
 use crate::borrow_tracker::stacked_borrows::diagnostics::TagHistory;
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index f95177684aee6..8c8ed9c4ddc3b 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -13,9 +13,8 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::Namespace;
 use rustc_hir::def_id::DefId;
 use rustc_middle::ty::{
-    self,
+    self, Ty, TyCtxt,
     layout::{LayoutCx, LayoutOf},
-    Ty, TyCtxt,
 };
 use rustc_target::spec::abi::Abi;
 
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index cba99c0bd7a81..10e5882b5ba89 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -7,12 +7,12 @@ use std::time::Duration;
 
 use rand::RngCore;
 
-use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_apfloat::Float;
+use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_hir::{
-    def::{DefKind, Namespace},
-    def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE},
     Safety,
+    def::{DefKind, Namespace},
+    def_id::{CRATE_DEF_INDEX, CrateNum, DefId, LOCAL_CRATE},
 };
 use rustc_index::IndexVec;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
@@ -21,9 +21,8 @@ use rustc_middle::middle::exported_symbols::ExportedSymbol;
 use rustc_middle::mir;
 use rustc_middle::ty::layout::{FnAbiOf, MaybeResult};
 use rustc_middle::ty::{
-    self,
+    self, FloatTy, IntTy, Ty, TyCtxt, UintTy,
     layout::{LayoutOf, TyAndLayout},
-    FloatTy, IntTy, Ty, TyCtxt, UintTy,
 };
 use rustc_session::config::CrateType;
 use rustc_span::{Span, Symbol};
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 7acc99a8af03b..3eeb11dbbb4a0 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -9,12 +9,12 @@ use rustc_middle::{
     mir,
     ty::{self, FloatTy},
 };
-use rustc_span::{sym, Symbol};
+use rustc_span::{Symbol, sym};
 use rustc_target::abi::Size;
 
 use crate::*;
 use atomic::EvalContextExt as _;
-use helpers::{check_arg_count, ToHost, ToSoft};
+use helpers::{ToHost, ToSoft, check_arg_count};
 use simd::EvalContextExt as _;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index e22306ca82fcf..2bc11d63a3951 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -3,10 +3,10 @@ use either::Either;
 use rustc_apfloat::{Float, Round};
 use rustc_middle::ty::layout::{HasParamEnv, LayoutOf};
 use rustc_middle::{mir, ty, ty::FloatTy};
-use rustc_span::{sym, Symbol};
+use rustc_span::{Symbol, sym};
 use rustc_target::abi::{Endian, HasDataLayout};
 
-use crate::helpers::{bool_to_simd_element, check_arg_count, simd_element_to_bool, ToHost, ToSoft};
+use crate::helpers::{ToHost, ToSoft, bool_to_simd_element, check_arg_count, simd_element_to_bool};
 use crate::*;
 
 #[derive(Copy, Clone)]
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 8a59206943d18..b39f88dd1c9dc 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -113,13 +113,13 @@ pub type PlaceTy<'tcx> = interpret::PlaceTy<'tcx, machine::Provenance>;
 pub type MPlaceTy<'tcx> = interpret::MPlaceTy<'tcx, machine::Provenance>;
 
 pub use crate::intrinsics::EvalContextExt as _;
+pub use crate::shims::EmulateItemResult;
 pub use crate::shims::env::{EnvVars, EvalContextExt as _};
 pub use crate::shims::foreign_items::{DynSym, EvalContextExt as _};
 pub use crate::shims::os_str::EvalContextExt as _;
 pub use crate::shims::panic::{CatchUnwindData, EvalContextExt as _};
 pub use crate::shims::time::EvalContextExt as _;
 pub use crate::shims::tls::TlsData;
-pub use crate::shims::EmulateItemResult;
 
 pub use crate::alloc_addresses::{EvalContextExt as _, ProvenanceMode};
 pub use crate::alloc_bytes::MiriAllocBytes;
@@ -140,11 +140,11 @@ pub use crate::concurrency::{
     },
 };
 pub use crate::diagnostics::{
-    report_error, EvalContextExt as _, NonHaltingDiagnostic, TerminationInfo,
+    EvalContextExt as _, NonHaltingDiagnostic, TerminationInfo, report_error,
 };
 pub use crate::eval::{
-    create_ecx, eval_entry, AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, RejectOpWith,
-    ValidationMode,
+    AlignmentCheck, BacktraceStyle, IsolatedOp, MiriConfig, RejectOpWith, ValidationMode,
+    create_ecx, eval_entry,
 };
 pub use crate::helpers::{AccessKind, EvalContextExt as _};
 pub use crate::machine::{
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index bde94cec87f8d..b93feeeee3365 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -8,9 +8,9 @@ use std::fmt;
 use std::path::Path;
 use std::process;
 
-use rand::rngs::StdRng;
 use rand::Rng;
 use rand::SeedableRng;
+use rand::rngs::StdRng;
 
 use rustc_attr::InlineAttr;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -20,9 +20,8 @@ use rustc_middle::{
     mir,
     query::TyCtxtAt,
     ty::{
-        self,
+        self, Instance, Ty, TyCtxt,
         layout::{HasTyCtxt, LayoutCx, LayoutError, LayoutOf, TyAndLayout},
-        Instance, Ty, TyCtxt,
     },
 };
 use rustc_session::config::InliningThreshold;
@@ -1080,13 +1079,10 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         // Call the lang item.
         let panic = ecx.tcx.lang_items().get(reason.lang_item()).unwrap();
         let panic = ty::Instance::mono(ecx.tcx.tcx, panic);
-        ecx.call_function(
-            panic,
-            Abi::Rust,
-            &[],
-            None,
-            StackPopCleanup::Goto { ret: None, unwind: mir::UnwindAction::Unreachable },
-        )?;
+        ecx.call_function(panic, Abi::Rust, &[], None, StackPopCleanup::Goto {
+            ret: None,
+            unwind: mir::UnwindAction::Unreachable,
+        })?;
         Ok(())
     }
 
diff --git a/src/tools/miri/src/operator.rs b/src/tools/miri/src/operator.rs
index bc44e672bd85e..1b6a7255eefbe 100644
--- a/src/tools/miri/src/operator.rs
+++ b/src/tools/miri/src/operator.rs
@@ -1,6 +1,6 @@
 use std::iter;
 
-use rand::{seq::IteratorRandom, Rng};
+use rand::{Rng, seq::IteratorRandom};
 use rustc_apfloat::{Float, FloatConvert};
 use rustc_middle::mir;
 use rustc_target::abi::Size;
diff --git a/src/tools/miri/src/shims/backtrace.rs b/src/tools/miri/src/shims/backtrace.rs
index 9bb6777a9b047..edff17c0514ce 100644
--- a/src/tools/miri/src/shims/backtrace.rs
+++ b/src/tools/miri/src/shims/backtrace.rs
@@ -2,7 +2,7 @@ use crate::*;
 use rustc_ast::ast::Mutability;
 use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::{self, Instance, Ty};
-use rustc_span::{hygiene, BytePos, Loc, Symbol};
+use rustc_span::{BytePos, Loc, Symbol, hygiene};
 use rustc_target::{abi::Size, spec::abi::Abi};
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
diff --git a/src/tools/miri/src/shims/extern_static.rs b/src/tools/miri/src/shims/extern_static.rs
index 17ac2638a69f4..788de8162cb70 100644
--- a/src/tools/miri/src/shims/extern_static.rs
+++ b/src/tools/miri/src/shims/extern_static.rs
@@ -63,10 +63,10 @@ impl<'tcx> MiriMachine<'tcx> {
 
         match this.tcx.sess.target.os.as_ref() {
             "linux" => {
-                Self::null_ptr_extern_statics(
-                    this,
-                    &["__cxa_thread_atexit_impl", "__clock_gettime64"],
-                )?;
+                Self::null_ptr_extern_statics(this, &[
+                    "__cxa_thread_atexit_impl",
+                    "__clock_gettime64",
+                ])?;
                 Self::weak_symbol_extern_statics(this, &["getrandom", "statx"])?;
             }
             "freebsd" => {
diff --git a/src/tools/miri/src/shims/os_str.rs b/src/tools/miri/src/shims/os_str.rs
index 533992e35ab17..a1be2ae8b588b 100644
--- a/src/tools/miri/src/shims/os_str.rs
+++ b/src/tools/miri/src/shims/os_str.rs
@@ -7,8 +7,8 @@ use std::os::unix::ffi::{OsStrExt, OsStringExt};
 #[cfg(windows)]
 use std::os::windows::ffi::{OsStrExt, OsStringExt};
 
-use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf;
 
 use crate::*;
 
diff --git a/src/tools/miri/src/shims/panic.rs b/src/tools/miri/src/shims/panic.rs
index ab705ddccab6e..44f942cb4c58c 100644
--- a/src/tools/miri/src/shims/panic.rs
+++ b/src/tools/miri/src/shims/panic.rs
@@ -13,8 +13,8 @@
 
 use rustc_ast::Mutability;
 use rustc_middle::{mir, ty};
-use rustc_target::spec::abi::Abi;
 use rustc_target::spec::PanicStrategy;
+use rustc_target::spec::abi::Abi;
 
 use crate::*;
 use helpers::check_arg_count;
@@ -248,13 +248,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Call the lang item associated with this message.
                 let fn_item = this.tcx.require_lang_item(msg.panic_function(), None);
                 let instance = ty::Instance::mono(this.tcx.tcx, fn_item);
-                this.call_function(
-                    instance,
-                    Abi::Rust,
-                    &[],
-                    None,
-                    StackPopCleanup::Goto { ret: None, unwind },
-                )?;
+                this.call_function(instance, Abi::Rust, &[], None, StackPopCleanup::Goto {
+                    ret: None,
+                    unwind,
+                })?;
             }
         }
         Ok(())
diff --git a/src/tools/miri/src/shims/tls.rs b/src/tools/miri/src/shims/tls.rs
index 52d83cd72997e..b3ea7098dfe81 100644
--- a/src/tools/miri/src/shims/tls.rs
+++ b/src/tools/miri/src/shims/tls.rs
@@ -1,7 +1,7 @@
 //! Implement thread-local storage.
 
-use std::collections::btree_map::Entry as BTreeEntry;
 use std::collections::BTreeMap;
+use std::collections::btree_map::Entry as BTreeEntry;
 use std::task::Poll;
 
 use rustc_middle::ty;
diff --git a/src/tools/miri/src/shims/unix/env.rs b/src/tools/miri/src/shims/unix/env.rs
index 54bf3a3ae8295..324607cc1eda3 100644
--- a/src/tools/miri/src/shims/unix/env.rs
+++ b/src/tools/miri/src/shims/unix/env.rs
@@ -4,8 +4,8 @@ use std::io::ErrorKind;
 use std::mem;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf;
 use rustc_target::abi::Size;
 
 use crate::*;
diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index 48bf959538b4f..6b78ce7ad47bb 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -25,49 +25,64 @@ pub(crate) enum FlockOp {
 pub trait FileDescription: std::fmt::Debug + Any {
     fn name(&self) -> &'static str;
 
-    /// Reads as much as possible into the given buffer, and returns the number of bytes read.
+    /// Reads as much as possible into the given buffer `ptr`.
+    /// `len` indicates how many bytes we should try to read.
+    /// `dest` is where the return value should be stored: number of bytes read, or `-1` in case of error.
     fn read<'tcx>(
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _bytes: &mut [u8],
+        _ptr: Pointer,
+        _len: usize,
+        _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
         throw_unsup_format!("cannot read from {}", self.name());
     }
 
-    /// Writes as much as possible from the given buffer, and returns the number of bytes written.
+    /// Writes as much as possible from the given buffer `ptr`.
+    /// `len` indicates how many bytes we should try to write.
+    /// `dest` is where the return value should be stored: number of bytes written, or `-1` in case of error.
     fn write<'tcx>(
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _bytes: &[u8],
+        _ptr: Pointer,
+        _len: usize,
+        _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
         throw_unsup_format!("cannot write to {}", self.name());
     }
 
-    /// Reads as much as possible into the given buffer from a given offset,
-    /// and returns the number of bytes read.
+    /// Reads as much as possible into the given buffer `ptr` from a given offset.
+    /// `len` indicates how many bytes we should try to read.
+    /// `dest` is where the return value should be stored: number of bytes read, or `-1` in case of error.
     fn pread<'tcx>(
         &self,
         _communicate_allowed: bool,
-        _bytes: &mut [u8],
         _offset: u64,
+        _ptr: Pointer,
+        _len: usize,
+        _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
         throw_unsup_format!("cannot pread from {}", self.name());
     }
 
-    /// Writes as much as possible from the given buffer starting at a given offset,
-    /// and returns the number of bytes written.
+    /// Writes as much as possible from the given buffer `ptr` starting at a given offset.
+    /// `ptr` is the pointer to the user supplied read buffer.
+    /// `len` indicates how many bytes we should try to write.
+    /// `dest` is where the return value should be stored: number of bytes written, or `-1` in case of error.
     fn pwrite<'tcx>(
         &self,
         _communicate_allowed: bool,
-        _bytes: &[u8],
+        _ptr: Pointer,
+        _len: usize,
         _offset: u64,
+        _dest: &MPlaceTy<'tcx>,
         _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
         throw_unsup_format!("cannot pwrite to {}", self.name());
     }
 
@@ -125,14 +140,18 @@ impl FileDescription for io::Stdin {
         &self,
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        bytes: &mut [u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let mut bytes = vec![0; len];
         if !communicate_allowed {
             // We want isolation mode to be deterministic, so we have to disallow all reads, even stdin.
             helpers::isolation_abort_error("`read` from stdin")?;
         }
-        Ok(Read::read(&mut { self }, bytes))
+        let result = Read::read(&mut { self }, &mut bytes);
+        ecx.return_read_bytes_and_count(ptr, &bytes, result, dest)
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -149,9 +168,12 @@ impl FileDescription for io::Stdout {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &[u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let bytes = ecx.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
         // We allow writing to stderr even with isolation enabled.
         let result = Write::write(&mut { self }, bytes);
         // Stdout is buffered, flush to make sure it appears on the
@@ -160,8 +182,7 @@ impl FileDescription for io::Stdout {
         // the host -- there is no good in adding extra buffering
         // here.
         io::stdout().flush().unwrap();
-
-        Ok(result)
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -178,12 +199,16 @@ impl FileDescription for io::Stderr {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &[u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let bytes = ecx.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
         // We allow writing to stderr even with isolation enabled.
         // No need to flush, stderr is not buffered.
-        Ok(Write::write(&mut { self }, bytes))
+        let result = Write::write(&mut { self }, bytes);
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -204,11 +229,14 @@ impl FileDescription for NullOutput {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &[u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        _ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
         // We just don't write anything, but report to the user that we did.
-        Ok(Ok(bytes.len()))
+        let result = Ok(len);
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 }
 
@@ -535,7 +563,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         buf: Pointer,
         count: u64,
         offset: Option<i128>,
-    ) -> InterpResult<'tcx, Scalar> {
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
         // Isolation check is done via `FileDescription` trait.
@@ -550,48 +579,35 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let count = count
             .min(u64::try_from(this.target_isize_max()).unwrap())
             .min(u64::try_from(isize::MAX).unwrap());
+        let count = usize::try_from(count).unwrap(); // now it fits in a `usize`
         let communicate = this.machine.communicate();
 
         // We temporarily dup the FD to be able to retain mutable access to `this`.
         let Some(fd) = this.machine.fds.get(fd_num) else {
             trace!("read: FD not found");
-            return Ok(Scalar::from_target_isize(this.fd_not_found()?, this));
+            let res: i32 = this.fd_not_found()?;
+            this.write_int(res, dest)?;
+            return Ok(());
         };
 
         trace!("read: FD mapped to {fd:?}");
         // We want to read at most `count` bytes. We are sure that `count` is not negative
         // because it was a target's `usize`. Also we are sure that its smaller than
         // `usize::MAX` because it is bounded by the host's `isize`.
-        let mut bytes = vec![0; usize::try_from(count).unwrap()];
-        let result = match offset {
-            None => fd.read(&fd, communicate, &mut bytes, this),
+
+        match offset {
+            None => fd.read(&fd, communicate, buf, count, dest, this)?,
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
                     this.set_last_error(einval)?;
-                    return Ok(Scalar::from_target_isize(-1, this));
+                    this.write_int(-1, dest)?;
+                    return Ok(());
                 };
-                fd.pread(communicate, &mut bytes, offset, this)
+                fd.pread(communicate, offset, buf, count, dest, this)?
             }
         };
-
-        // `File::read` never returns a value larger than `count`, so this cannot fail.
-        match result?.map(|c| i64::try_from(c).unwrap()) {
-            Ok(read_bytes) => {
-                // If reading to `bytes` did not fail, we write those bytes to the buffer.
-                // Crucially, if fewer than `bytes.len()` bytes were read, only write
-                // that much into the output buffer!
-                this.write_bytes_ptr(
-                    buf,
-                    bytes[..usize::try_from(read_bytes).unwrap()].iter().copied(),
-                )?;
-                Ok(Scalar::from_target_isize(read_bytes, this))
-            }
-            Err(e) => {
-                this.set_last_error_from_io_error(e)?;
-                Ok(Scalar::from_target_isize(-1, this))
-            }
-        }
+        Ok(())
     }
 
     fn write(
@@ -600,7 +616,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         buf: Pointer,
         count: u64,
         offset: Option<i128>,
-    ) -> InterpResult<'tcx, Scalar> {
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
         // Isolation check is done via `FileDescription` trait.
@@ -613,27 +630,72 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let count = count
             .min(u64::try_from(this.target_isize_max()).unwrap())
             .min(u64::try_from(isize::MAX).unwrap());
+        let count = usize::try_from(count).unwrap(); // now it fits in a `usize`
         let communicate = this.machine.communicate();
 
-        let bytes = this.read_bytes_ptr_strip_provenance(buf, Size::from_bytes(count))?.to_owned();
         // We temporarily dup the FD to be able to retain mutable access to `this`.
         let Some(fd) = this.machine.fds.get(fd_num) else {
-            return Ok(Scalar::from_target_isize(this.fd_not_found()?, this));
+            let res: i32 = this.fd_not_found()?;
+            this.write_int(res, dest)?;
+            return Ok(());
         };
 
-        let result = match offset {
-            None => fd.write(&fd, communicate, &bytes, this),
+        match offset {
+            None => fd.write(&fd, communicate, buf, count, dest, this)?,
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
                     this.set_last_error(einval)?;
-                    return Ok(Scalar::from_target_isize(-1, this));
+                    this.write_int(-1, dest)?;
+                    return Ok(());
                 };
-                fd.pwrite(communicate, &bytes, offset, this)
+                fd.pwrite(communicate, buf, count, offset, dest, this)?
             }
         };
+        Ok(())
+    }
 
-        let result = result?.map(|c| i64::try_from(c).unwrap());
-        Ok(Scalar::from_target_isize(this.try_unwrap_io_result(result)?, this))
+    /// Helper to implement `FileDescription::read`:
+    /// `result` should be the return value of some underlying `read` call that used `bytes` as its output buffer.
+    /// The length of `bytes` must not exceed either the host's or the target's `isize`.
+    /// If `Result` indicates success, `bytes` is written to `buf` and the size is written to `dest`.
+    /// Otherwise, `-1` is written to `dest` and the last libc error is set appropriately.
+    fn return_read_bytes_and_count(
+        &mut self,
+        buf: Pointer,
+        bytes: &[u8],
+        result: io::Result<usize>,
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        match result {
+            Ok(read_bytes) => {
+                // If reading to `bytes` did not fail, we write those bytes to the buffer.
+                // Crucially, if fewer than `bytes.len()` bytes were read, only write
+                // that much into the output buffer!
+                this.write_bytes_ptr(buf, bytes[..read_bytes].iter().copied())?;
+                // The actual read size is always less than what got originally requested so this cannot fail.
+                this.write_int(u64::try_from(read_bytes).unwrap(), dest)?;
+                return Ok(());
+            }
+            Err(e) => {
+                this.set_last_error_from_io_error(e)?;
+                this.write_int(-1, dest)?;
+                return Ok(());
+            }
+        }
+    }
+
+    /// This function writes the number of written bytes (given in `result`) to `dest`, or sets the
+    /// last libc error and writes -1 to dest.
+    fn return_written_byte_count_or_error(
+        &mut self,
+        result: io::Result<usize>,
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let result = this.try_unwrap_io_result(result.map(|c| i64::try_from(c).unwrap()))?;
+        this.write_int(result, dest)?;
+        Ok(())
     }
 }
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 73f933264fdf5..57dae05025002 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -92,8 +92,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let fd = this.read_scalar(fd)?.to_i32()?;
                 let buf = this.read_pointer(buf)?;
                 let count = this.read_target_usize(count)?;
-                let result = this.read(fd, buf, count, None)?;
-                this.write_scalar(result, dest)?;
+                this.read(fd, buf, count, None, dest)?;
             }
             "write" => {
                 let [fd, buf, n] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
@@ -101,9 +100,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let buf = this.read_pointer(buf)?;
                 let count = this.read_target_usize(n)?;
                 trace!("Called write({:?}, {:?}, {:?})", fd, buf, count);
-                let result = this.write(fd, buf, count, None)?;
-                // Now, `result` is the value we return back to the program.
-                this.write_scalar(result, dest)?;
+                this.write(fd, buf, count, None, dest)?;
             }
             "pread" => {
                 let [fd, buf, count, offset] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
@@ -111,8 +108,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let buf = this.read_pointer(buf)?;
                 let count = this.read_target_usize(count)?;
                 let offset = this.read_scalar(offset)?.to_int(this.libc_ty_layout("off_t").size)?;
-                let result = this.read(fd, buf, count, Some(offset))?;
-                this.write_scalar(result, dest)?;
+                this.read(fd, buf, count, Some(offset), dest)?;
             }
             "pwrite" => {
                 let [fd, buf, n, offset] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
@@ -121,9 +117,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let count = this.read_target_usize(n)?;
                 let offset = this.read_scalar(offset)?.to_int(this.libc_ty_layout("off_t").size)?;
                 trace!("Called pwrite({:?}, {:?}, {:?}, {:?})", fd, buf, count, offset);
-                let result = this.write(fd, buf, count, Some(offset))?;
-                // Now, `result` is the value we return back to the program.
-                this.write_scalar(result, dest)?;
+                this.write(fd, buf, count, Some(offset), dest)?;
             }
             "pread64" => {
                 let [fd, buf, count, offset] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
@@ -131,8 +125,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let buf = this.read_pointer(buf)?;
                 let count = this.read_target_usize(count)?;
                 let offset = this.read_scalar(offset)?.to_int(this.libc_ty_layout("off64_t").size)?;
-                let result = this.read(fd, buf, count, Some(offset))?;
-                this.write_scalar(result, dest)?;
+                this.read(fd, buf, count, Some(offset), dest)?;
             }
             "pwrite64" => {
                 let [fd, buf, n, offset] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
@@ -141,9 +134,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let count = this.read_target_usize(n)?;
                 let offset = this.read_scalar(offset)?.to_int(this.libc_ty_layout("off64_t").size)?;
                 trace!("Called pwrite64({:?}, {:?}, {:?}, {:?})", fd, buf, count, offset);
-                let result = this.write(fd, buf, count, Some(offset))?;
-                // Now, `result` is the value we return back to the program.
-                this.write_scalar(result, dest)?;
+                this.write(fd, buf, count, Some(offset), dest)?;
             }
             "close" => {
                 let [fd] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index e1697a4741559..1f7e1b3bd7c07 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -2,7 +2,7 @@
 
 use std::borrow::Cow;
 use std::fs::{
-    read_dir, remove_dir, remove_file, rename, DirBuilder, File, FileType, OpenOptions, ReadDir,
+    DirBuilder, File, FileType, OpenOptions, ReadDir, read_dir, remove_dir, remove_file, rename,
 };
 use std::io::{self, ErrorKind, IsTerminal, Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
@@ -34,32 +34,43 @@ impl FileDescription for FileHandle {
         &self,
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        bytes: &mut [u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok((&mut &self.file).read(bytes))
+        let mut bytes = vec![0; len];
+        let result = (&mut &self.file).read(&mut bytes);
+        ecx.return_read_bytes_and_count(ptr, &bytes, result, dest)
     }
 
     fn write<'tcx>(
         &self,
         _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        bytes: &[u8],
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok((&mut &self.file).write(bytes))
+        let bytes = ecx.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
+        let result = (&mut &self.file).write(bytes);
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn pread<'tcx>(
         &self,
         communicate_allowed: bool,
-        bytes: &mut [u8],
         offset: u64,
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
+        let mut bytes = vec![0; len];
         // Emulates pread using seek + read + seek to restore cursor position.
         // Correctness of this emulation relies on sequential nature of Miri execution.
         // The closure is used to emulate `try` block, since we "bubble" `io::Error` using `?`.
@@ -67,27 +78,31 @@ impl FileDescription for FileHandle {
         let mut f = || {
             let cursor_pos = file.stream_position()?;
             file.seek(SeekFrom::Start(offset))?;
-            let res = file.read(bytes);
+            let res = file.read(&mut bytes);
             // Attempt to restore cursor position even if the read has failed
             file.seek(SeekFrom::Start(cursor_pos))
                 .expect("failed to restore file position, this shouldn't be possible");
             res
         };
-        Ok(f())
+        let result = f();
+        ecx.return_read_bytes_and_count(ptr, &bytes, result, dest)
     }
 
     fn pwrite<'tcx>(
         &self,
         communicate_allowed: bool,
-        bytes: &[u8],
+        ptr: Pointer,
+        len: usize,
         offset: u64,
-        _ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+        dest: &MPlaceTy<'tcx>,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
         // Emulates pwrite using seek + write + seek to restore cursor position.
         // Correctness of this emulation relies on sequential nature of Miri execution.
         // The closure is used to emulate `try` block, since we "bubble" `io::Error` using `?`.
         let file = &mut &self.file;
+        let bytes = ecx.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
         let mut f = || {
             let cursor_pos = file.stream_position()?;
             file.seek(SeekFrom::Start(offset))?;
@@ -97,7 +112,8 @@ impl FileDescription for FileHandle {
                 .expect("failed to restore file position, this shouldn't be possible");
             res
         };
-        Ok(f())
+        let result = f();
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 
     fn seek<'tcx>(
@@ -173,7 +189,7 @@ impl FileDescription for FileHandle {
             use windows_sys::Win32::{
                 Foundation::{ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, FALSE, HANDLE, TRUE},
                 Storage::FileSystem::{
-                    LockFileEx, UnlockFile, LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY,
+                    LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY, LockFileEx, UnlockFile,
                 },
             };
             let fh = self.file.as_raw_handle() as HANDLE;
diff --git a/src/tools/miri/src/shims/unix/linux/eventfd.rs b/src/tools/miri/src/shims/unix/linux/eventfd.rs
index 77d16a032aae9..d1d461daa993e 100644
--- a/src/tools/miri/src/shims/unix/linux/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux/eventfd.rs
@@ -2,18 +2,12 @@
 use std::cell::{Cell, RefCell};
 use std::io;
 use std::io::{Error, ErrorKind};
-use std::mem;
-
-use rustc_target::abi::Endian;
 
 use crate::shims::unix::fd::FileDescriptionRef;
 use crate::shims::unix::linux::epoll::{EpollReadyEvents, EvalContextExt as _};
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
-// We'll only do reads and writes in chunks of size u64.
-const U64_ARRAY_SIZE: usize = mem::size_of::<u64>();
-
 /// Maximum value that the eventfd counter can hold.
 const MAX_COUNTER: u64 = u64::MAX - 1;
 
@@ -62,37 +56,50 @@ impl FileDescription for Event {
         &self,
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &mut [u8],
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
+        // We're treating the buffer as a `u64`.
+        let ty = ecx.machine.layouts.u64;
         // Check the size of slice, and return error only if the size of the slice < 8.
-        let Some(bytes) = bytes.first_chunk_mut::<U64_ARRAY_SIZE>() else {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
-        };
+        if len < ty.size.bytes_usize() {
+            ecx.set_last_error_from_io_error(Error::from(ErrorKind::InvalidInput))?;
+            ecx.write_int(-1, dest)?;
+            return Ok(());
+        }
+
+        // eventfd read at the size of u64.
+        let buf_place = ecx.ptr_to_mplace_unaligned(ptr, ty);
+
         // Block when counter == 0.
         let counter = self.counter.get();
         if counter == 0 {
             if self.is_nonblock {
-                return Ok(Err(Error::from(ErrorKind::WouldBlock)));
-            } else {
-                //FIXME: blocking is not supported
-                throw_unsup_format!("eventfd: blocking is unsupported");
+                ecx.set_last_error_from_io_error(Error::from(ErrorKind::WouldBlock))?;
+                ecx.write_int(-1, dest)?;
+                return Ok(());
             }
+
+            throw_unsup_format!("eventfd: blocking is unsupported");
         } else {
             // Synchronize with all prior `write` calls to this FD.
             ecx.acquire_clock(&self.clock.borrow());
-            // Return the counter in the host endianness using the buffer provided by caller.
-            *bytes = match ecx.tcx.sess.target.endian {
-                Endian::Little => counter.to_le_bytes(),
-                Endian::Big => counter.to_be_bytes(),
-            };
+
+            // Give old counter value to userspace, and set counter value to 0.
+            ecx.write_int(counter, &buf_place)?;
             self.counter.set(0);
+
             // When any of the event happened, we check and update the status of all supported event
             // types for current file description.
             ecx.check_and_update_readiness(self_ref)?;
 
-            return Ok(Ok(U64_ARRAY_SIZE));
+            // Tell userspace how many bytes we wrote.
+            ecx.write_int(buf_place.layout.size.bytes(), dest)?;
         }
+
+        Ok(())
     }
 
     /// A write call adds the 8-byte integer value supplied in
@@ -111,21 +118,27 @@ impl FileDescription for Event {
         &self,
         self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &[u8],
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
+    ) -> InterpResult<'tcx> {
+        // We're treating the buffer as a `u64`.
+        let ty = ecx.machine.layouts.u64;
         // Check the size of slice, and return error only if the size of the slice < 8.
-        let Some(bytes) = bytes.first_chunk::<U64_ARRAY_SIZE>() else {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
-        };
-        // Convert from bytes to int according to host endianness.
-        let num = match ecx.tcx.sess.target.endian {
-            Endian::Little => u64::from_le_bytes(*bytes),
-            Endian::Big => u64::from_be_bytes(*bytes),
-        };
+        if len < ty.layout.size.bytes_usize() {
+            let result = Err(Error::from(ErrorKind::InvalidInput));
+            return ecx.return_written_byte_count_or_error(result, dest);
+        }
+
+        // Read the user supplied value from the pointer.
+        let buf_place = ecx.ptr_to_mplace_unaligned(ptr, ty);
+        let num = ecx.read_scalar(&buf_place)?.to_u64()?;
+
         // u64::MAX as input is invalid because the maximum value of counter is u64::MAX - 1.
         if num == u64::MAX {
-            return Ok(Err(Error::from(ErrorKind::InvalidInput)));
+            let result = Err(Error::from(ErrorKind::InvalidInput));
+            return ecx.return_written_byte_count_or_error(result, dest);
         }
         // If the addition does not let the counter to exceed the maximum value, update the counter.
         // Else, block.
@@ -137,20 +150,20 @@ impl FileDescription for Event {
                 }
                 self.counter.set(new_count);
             }
-            None | Some(u64::MAX) => {
+            None | Some(u64::MAX) =>
                 if self.is_nonblock {
-                    return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    let result = Err(Error::from(ErrorKind::WouldBlock));
+                    return ecx.return_written_byte_count_or_error(result, dest);
                 } else {
-                    //FIXME: blocking is not supported
                     throw_unsup_format!("eventfd: blocking is unsupported");
-                }
-            }
+                },
         };
         // When any of the event happened, we check and update the status of all supported event
         // types for current file description.
         ecx.check_and_update_readiness(self_ref)?;
 
-        Ok(Ok(U64_ARRAY_SIZE))
+        // Return how many bytes we read.
+        ecx.write_int(buf_place.layout.size.bytes(), dest)
     }
 }
 
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index 127aef29244c5..db6872319ea48 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -7,6 +7,8 @@ use std::collections::VecDeque;
 use std::io;
 use std::io::{Error, ErrorKind, Read};
 
+use rustc_target::abi::Size;
+
 use crate::shims::unix::fd::{FileDescriptionRef, WeakFileDescriptionRef};
 use crate::shims::unix::linux::epoll::{EpollReadyEvents, EvalContextExt as _};
 use crate::shims::unix::*;
@@ -126,14 +128,17 @@ impl FileDescription for AnonSocket {
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &mut [u8],
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
-        let request_byte_size = bytes.len();
+    ) -> InterpResult<'tcx> {
+        let mut bytes = vec![0; len];
 
         // Always succeed on read size 0.
-        if request_byte_size == 0 {
-            return Ok(Ok(0));
+        if len == 0 {
+            let result = Ok(0);
+            return ecx.return_read_bytes_and_count(ptr, &bytes, result, dest);
         }
 
         let Some(readbuf) = &self.readbuf else {
@@ -146,7 +151,8 @@ impl FileDescription for AnonSocket {
             if self.peer_fd().upgrade().is_none() {
                 // Socketpair with no peer and empty buffer.
                 // 0 bytes successfully read indicates end-of-file.
-                return Ok(Ok(0));
+                let result = Ok(0);
+                return ecx.return_read_bytes_and_count(ptr, &bytes, result, dest);
             } else {
                 if self.is_nonblock {
                     // Non-blocking socketpair with writer and empty buffer.
@@ -154,7 +160,8 @@ impl FileDescription for AnonSocket {
                     // EAGAIN or EWOULDBLOCK can be returned for socket,
                     // POSIX.1-2001 allows either error to be returned for this case.
                     // Since there is no ErrorKind for EAGAIN, WouldBlock is used.
-                    return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                    let result = Err(Error::from(ErrorKind::WouldBlock));
+                    return ecx.return_read_bytes_and_count(ptr, &bytes, result, dest);
                 } else {
                     // Blocking socketpair with writer and empty buffer.
                     // FIXME: blocking is currently not supported
@@ -170,7 +177,7 @@ impl FileDescription for AnonSocket {
 
         // Do full read / partial read based on the space available.
         // Conveniently, `read` exists on `VecDeque` and has exactly the desired behavior.
-        let actual_read_size = readbuf.buf.read(bytes).unwrap();
+        let actual_read_size = readbuf.buf.read(&mut bytes).unwrap();
 
         // Need to drop before others can access the readbuf again.
         drop(readbuf);
@@ -186,28 +193,32 @@ impl FileDescription for AnonSocket {
             ecx.check_and_update_readiness(&peer_fd)?;
         }
 
-        return Ok(Ok(actual_read_size));
+        let result = Ok(actual_read_size);
+        ecx.return_read_bytes_and_count(ptr, &bytes, result, dest)
     }
 
     fn write<'tcx>(
         &self,
         _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        bytes: &[u8],
+        ptr: Pointer,
+        len: usize,
+        dest: &MPlaceTy<'tcx>,
         ecx: &mut MiriInterpCx<'tcx>,
-    ) -> InterpResult<'tcx, io::Result<usize>> {
-        let write_size = bytes.len();
+    ) -> InterpResult<'tcx> {
         // Always succeed on write size 0.
         // ("If count is zero and fd refers to a file other than a regular file, the results are not specified.")
-        if write_size == 0 {
-            return Ok(Ok(0));
+        if len == 0 {
+            let result = Ok(0);
+            return ecx.return_written_byte_count_or_error(result, dest);
         }
 
         // We are writing to our peer's readbuf.
         let Some(peer_fd) = self.peer_fd().upgrade() else {
             // If the upgrade from Weak to Rc fails, it indicates that all read ends have been
             // closed.
-            return Ok(Err(Error::from(ErrorKind::BrokenPipe)));
+            let result = Err(Error::from(ErrorKind::BrokenPipe));
+            return ecx.return_written_byte_count_or_error(result, dest);
         };
 
         let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf else {
@@ -221,7 +232,8 @@ impl FileDescription for AnonSocket {
         if available_space == 0 {
             if self.is_nonblock {
                 // Non-blocking socketpair with a full buffer.
-                return Ok(Err(Error::from(ErrorKind::WouldBlock)));
+                let result = Err(Error::from(ErrorKind::WouldBlock));
+                return ecx.return_written_byte_count_or_error(result, dest);
             } else {
                 // Blocking socketpair with a full buffer.
                 throw_unsup_format!("socketpair write: blocking isn't supported yet");
@@ -232,7 +244,8 @@ impl FileDescription for AnonSocket {
             writebuf.clock.join(clock);
         }
         // Do full write / partial write based on the space available.
-        let actual_write_size = write_size.min(available_space);
+        let actual_write_size = len.min(available_space);
+        let bytes = ecx.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
         writebuf.buf.extend(&bytes[..actual_write_size]);
 
         // Need to stop accessing peer_fd so that it can be notified.
@@ -242,7 +255,8 @@ impl FileDescription for AnonSocket {
         // The kernel does this even if the fd was already readable before, so we follow suit.
         ecx.check_and_update_readiness(&peer_fd)?;
 
-        return Ok(Ok(actual_write_size));
+        let result = Ok(actual_write_size);
+        ecx.return_written_byte_count_or_error(result, dest)
     }
 }
 
diff --git a/src/tools/miri/src/shims/x86/aesni.rs b/src/tools/miri/src/shims/x86/aesni.rs
index e4e1531157a42..dbbae0731e0b7 100644
--- a/src/tools/miri/src/shims/x86/aesni.rs
+++ b/src/tools/miri/src/shims/x86/aesni.rs
@@ -1,5 +1,5 @@
-use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
diff --git a/src/tools/miri/src/shims/x86/avx.rs b/src/tools/miri/src/shims/x86/avx.rs
index 1ddc9efcf6bae..bdc4fc9446915 100644
--- a/src/tools/miri/src/shims/x86/avx.rs
+++ b/src/tools/miri/src/shims/x86/avx.rs
@@ -1,14 +1,14 @@
 use rustc_apfloat::{ieee::Double, ieee::Single};
 use rustc_middle::mir;
-use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
 use super::{
-    bin_op_simd_float_all, conditional_dot_product, convert_float_to_int, horizontal_bin_op,
-    mask_load, mask_store, round_all, test_bits_masked, test_high_bits_masked, unary_op_ps,
-    FloatBinOp, FloatUnaryOp,
+    FloatBinOp, FloatUnaryOp, bin_op_simd_float_all, conditional_dot_product, convert_float_to_int,
+    horizontal_bin_op, mask_load, mask_store, round_all, test_bits_masked, test_high_bits_masked,
+    unary_op_ps,
 };
 use crate::*;
 
diff --git a/src/tools/miri/src/shims/x86/avx2.rs b/src/tools/miri/src/shims/x86/avx2.rs
index 74d4673bd825b..1dda1a10a0503 100644
--- a/src/tools/miri/src/shims/x86/avx2.rs
+++ b/src/tools/miri/src/shims/x86/avx2.rs
@@ -1,12 +1,12 @@
 use rustc_middle::mir;
-use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
 use super::{
-    horizontal_bin_op, int_abs, mask_load, mask_store, mpsadbw, packssdw, packsswb, packusdw,
-    packuswb, pmulhrsw, psign, shift_simd_by_scalar, shift_simd_by_simd, ShiftOp,
+    ShiftOp, horizontal_bin_op, int_abs, mask_load, mask_store, mpsadbw, packssdw, packsswb,
+    packusdw, packuswb, pmulhrsw, psign, shift_simd_by_scalar, shift_simd_by_simd,
 };
 use crate::*;
 
diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index d7241f87d0e8a..7c7a0935c47ab 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -1,8 +1,8 @@
 use rand::Rng as _;
 
-use rustc_apfloat::{ieee::Single, Float};
-use rustc_middle::ty::layout::LayoutOf as _;
+use rustc_apfloat::{Float, ieee::Single};
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::{mir, ty};
 use rustc_span::Symbol;
 use rustc_target::abi::Size;
diff --git a/src/tools/miri/src/shims/x86/sse.rs b/src/tools/miri/src/shims/x86/sse.rs
index 8de7ddc79313b..254d25bb5293a 100644
--- a/src/tools/miri/src/shims/x86/sse.rs
+++ b/src/tools/miri/src/shims/x86/sse.rs
@@ -3,8 +3,8 @@ use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
 use super::{
-    bin_op_simd_float_all, bin_op_simd_float_first, unary_op_ps, unary_op_ss, FloatBinOp,
-    FloatUnaryOp,
+    FloatBinOp, FloatUnaryOp, bin_op_simd_float_all, bin_op_simd_float_first, unary_op_ps,
+    unary_op_ss,
 };
 use crate::*;
 
diff --git a/src/tools/miri/src/shims/x86/sse2.rs b/src/tools/miri/src/shims/x86/sse2.rs
index bdb52a04a91d1..7c23e37266430 100644
--- a/src/tools/miri/src/shims/x86/sse2.rs
+++ b/src/tools/miri/src/shims/x86/sse2.rs
@@ -3,8 +3,8 @@ use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
 use super::{
-    bin_op_simd_float_all, bin_op_simd_float_first, convert_float_to_int, packssdw, packsswb,
-    packuswb, shift_simd_by_scalar, FloatBinOp, ShiftOp,
+    FloatBinOp, ShiftOp, bin_op_simd_float_all, bin_op_simd_float_first, convert_float_to_int,
+    packssdw, packsswb, packuswb, shift_simd_by_scalar,
 };
 use crate::*;
 
diff --git a/src/tools/miri/src/shims/x86/sse42.rs b/src/tools/miri/src/shims/x86/sse42.rs
index 4e50d5e5dcfbf..0b6e0d9e0d7e7 100644
--- a/src/tools/miri/src/shims/x86/sse42.rs
+++ b/src/tools/miri/src/shims/x86/sse42.rs
@@ -1,6 +1,6 @@
 use rustc_middle::mir;
-use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_middle::ty::Ty;
+use rustc_middle::ty::layout::LayoutOf as _;
 use rustc_span::Symbol;
 use rustc_target::abi::Size;
 use rustc_target::spec::abi::Abi;
diff --git a/src/tools/miri/test-cargo-miri/src/main.rs b/src/tools/miri/test-cargo-miri/src/main.rs
index 048577ef15a61..d171ec1c0d1c4 100644
--- a/src/tools/miri/test-cargo-miri/src/main.rs
+++ b/src/tools/miri/test-cargo-miri/src/main.rs
@@ -23,7 +23,7 @@ fn main() {
     // (We rely on the test runner to always disable isolation when passing no arguments.)
     if std::env::args().len() <= 1 {
         fn host_to_target_path(path: String) -> PathBuf {
-            use std::ffi::{c_char, CStr, CString};
+            use std::ffi::{CStr, CString, c_char};
 
             let path = CString::new(path).unwrap();
             let mut out = Vec::with_capacity(1024);
diff --git a/src/tools/miri/test-cargo-miri/subcrate/main.rs b/src/tools/miri/test-cargo-miri/subcrate/main.rs
index 52161098788b5..96f849e7633ac 100644
--- a/src/tools/miri/test-cargo-miri/subcrate/main.rs
+++ b/src/tools/miri/test-cargo-miri/subcrate/main.rs
@@ -5,7 +5,7 @@ fn main() {
     println!("subcrate running");
 
     fn host_to_target_path(path: String) -> PathBuf {
-        use std::ffi::{c_char, CStr, CString};
+        use std::ffi::{CStr, CString, c_char};
 
         let path = CString::new(path).unwrap();
         let mut out = Vec::with_capacity(1024);
diff --git a/src/tools/miri/test-cargo-miri/subcrate/test.rs b/src/tools/miri/test-cargo-miri/subcrate/test.rs
index 1681c721dc2e2..b60cf20339b77 100644
--- a/src/tools/miri/test-cargo-miri/subcrate/test.rs
+++ b/src/tools/miri/test-cargo-miri/subcrate/test.rs
@@ -8,7 +8,7 @@ fn main() {
     println!("subcrate testing");
 
     fn host_to_target_path(path: String) -> PathBuf {
-        use std::ffi::{c_char, CStr, CString};
+        use std::ffi::{CStr, CString, c_char};
 
         let path = CString::new(path).unwrap();
         let mut out = Vec::with_capacity(1024);
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs
index e28b0343135b5..279201df867cf 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/windows_join_main.rs
@@ -8,7 +8,7 @@
 use std::thread;
 
 use windows_sys::Win32::Foundation::{HANDLE, WAIT_OBJECT_0};
-use windows_sys::Win32::System::Threading::{WaitForSingleObject, INFINITE};
+use windows_sys::Win32::System::Threading::{INFINITE, WaitForSingleObject};
 
 // XXX HACK: This is how miri represents the handle for thread 0.
 // This value can be "legitimately" obtained by using `GetCurrentThread` with `DuplicateHandle`
diff --git a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs
index 4d48e839bb414..eee2979f3cff3 100644
--- a/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs
+++ b/src/tools/miri/tests/fail-dep/concurrency/windows_join_self.rs
@@ -8,7 +8,7 @@
 use std::thread;
 
 use windows_sys::Win32::Foundation::WAIT_OBJECT_0;
-use windows_sys::Win32::System::Threading::{GetCurrentThread, WaitForSingleObject, INFINITE};
+use windows_sys::Win32::System::Threading::{GetCurrentThread, INFINITE, WaitForSingleObject};
 
 fn main() {
     thread::spawn(|| {
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.rs b/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.rs
index 552a67419b247..f04927beb1632 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.rs
+++ b/src/tools/miri/tests/fail/alloc/deallocate-bad-alignment.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-bad-size.rs b/src/tools/miri/tests/fail/alloc/deallocate-bad-size.rs
index 906a3b52a2232..d818f3a9304ee 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-bad-size.rs
+++ b/src/tools/miri/tests/fail/alloc/deallocate-bad-size.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/alloc/deallocate-twice.rs b/src/tools/miri/tests/fail/alloc/deallocate-twice.rs
index ee514f4c55e15..340ca1f75ef90 100644
--- a/src/tools/miri/tests/fail/alloc/deallocate-twice.rs
+++ b/src/tools/miri/tests/fail/alloc/deallocate-twice.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-bad-size.rs b/src/tools/miri/tests/fail/alloc/reallocate-bad-size.rs
index 174e4f2276188..7b9ef1d9121c5 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-bad-size.rs
+++ b/src/tools/miri/tests/fail/alloc/reallocate-bad-size.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, realloc, Layout};
+use std::alloc::{Layout, alloc, realloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.rs b/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.rs
index ecdd3ae5fee75..9f9921b1817d9 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.rs
+++ b/src/tools/miri/tests/fail/alloc/reallocate-change-alloc.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, realloc, Layout};
+use std::alloc::{Layout, alloc, realloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/alloc/reallocate-dangling.rs b/src/tools/miri/tests/fail/alloc/reallocate-dangling.rs
index c605f68a7f63d..97357c629af63 100644
--- a/src/tools/miri/tests/fail/alloc/reallocate-dangling.rs
+++ b/src/tools/miri/tests/fail/alloc/reallocate-dangling.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, dealloc, realloc, Layout};
+use std::alloc::{Layout, alloc, dealloc, realloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.rs b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.rs
index 170bcf9590a76..44ec4129d6093 100644
--- a/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.rs
+++ b/src/tools/miri/tests/fail/both_borrows/invalidate_against_protector3.rs
@@ -1,7 +1,7 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 
-use std::alloc::{alloc, Layout};
+use std::alloc::{Layout, alloc};
 
 fn inner(x: *mut i32, _y: &i32) {
     // If `x` and `y` alias, retagging is fine with this... but we really
diff --git a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
index c8060d4c9cb76..df9a73a444eda 100644
--- a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
+++ b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
@@ -1,6 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 
 // `x` is strongly protected but covers zero bytes.
 // Let's see if deallocating the allocation x points to is UB:
diff --git a/src/tools/miri/tests/fail/data_race/fence_after_load.rs b/src/tools/miri/tests/fail/data_race/fence_after_load.rs
index 92cb4ccccf530..5dfb260c20bdc 100644
--- a/src/tools/miri/tests/fail/data_race/fence_after_load.rs
+++ b/src/tools/miri/tests/fail/data_race/fence_after_load.rs
@@ -3,8 +3,8 @@
 // Avoid accidental synchronization via address reuse inside `thread::spawn`.
 //@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
 
-use std::sync::atomic::{fence, AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering, fence};
 use std::thread;
 use std::time::Duration;
 
diff --git a/src/tools/miri/tests/fail/data_race/mixed_size_read.rs b/src/tools/miri/tests/fail/data_race/mixed_size_read.rs
index 61af972b3dca8..828b47f0a6576 100644
--- a/src/tools/miri/tests/fail/data_race/mixed_size_read.rs
+++ b/src/tools/miri/tests/fail/data_race/mixed_size_read.rs
@@ -2,7 +2,7 @@
 // Avoid accidental synchronization via address reuse inside `thread::spawn`.
 //@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
 
-use std::sync::atomic::{AtomicU16, AtomicU8, Ordering};
+use std::sync::atomic::{AtomicU8, AtomicU16, Ordering};
 use std::thread;
 
 fn convert(a: &AtomicU16) -> &[AtomicU8; 2] {
diff --git a/src/tools/miri/tests/fail/data_race/mixed_size_write.rs b/src/tools/miri/tests/fail/data_race/mixed_size_write.rs
index 12e51bb94296a..89afda2fff5c2 100644
--- a/src/tools/miri/tests/fail/data_race/mixed_size_write.rs
+++ b/src/tools/miri/tests/fail/data_race/mixed_size_write.rs
@@ -2,7 +2,7 @@
 // Avoid accidental synchronization via address reuse inside `thread::spawn`.
 //@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
 
-use std::sync::atomic::{AtomicU16, AtomicU8, Ordering};
+use std::sync::atomic::{AtomicU8, AtomicU16, Ordering};
 use std::thread;
 
 fn convert(a: &AtomicU16) -> &[AtomicU8; 2] {
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.rs
index a2739842bc135..a0fa49d3d6f6b 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.rs
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.rs
@@ -1,7 +1,8 @@
 fn main() {
     let x = &[0i32; 2];
     let x = x.as_ptr().wrapping_add(1);
-    // If the `!0` is interpreted as `isize`, it is just `-1` and hence harmless.
-    // However, this is unsigned arithmetic, so really this is `usize::MAX` and hence UB.
-    unsafe { x.byte_add(!0).read() }; //~ERROR: does not fit in an `isize`
+    // If `usize::MAX` is interpreted as `isize`, it is just `-1` and hence harmless.
+    let _ = unsafe { x.byte_offset(usize::MAX as isize) };
+    // However, `byte_add` uses unsigned arithmetic, so really this is `usize::MAX` and hence UB.
+    let _ = unsafe { x.byte_add(usize::MAX) }; //~ERROR: does not fit in an `isize`
 }
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.stderr
index a5f046ec4030a..e03bdfdb85d47 100644
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/ptr_offset_unsigned_overflow.stderr
@@ -1,8 +1,8 @@
 error: Undefined Behavior: overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
   --> tests/fail/intrinsics/ptr_offset_unsigned_overflow.rs:LL:CC
    |
-LL |     unsafe { x.byte_add(!0).read() };
-   |              ^^^^^^^^^^^^^^ overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
+LL |     let _ = unsafe { x.byte_add(usize::MAX) };
+   |                      ^^^^^^^^^^^^^^^^^^^^^^ overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.rs b/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.rs
index 545875a582a46..cebad507ea9d2 100644
--- a/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.rs
+++ b/src/tools/miri/tests/fail/should-pass/cpp20_rwc_syncs.rs
@@ -8,7 +8,7 @@
 // so we have to stick to C++11 emulation from existing research.
 
 use std::sync::atomic::Ordering::*;
-use std::sync::atomic::{fence, AtomicUsize};
+use std::sync::atomic::{AtomicUsize, fence};
 use std::thread::spawn;
 
 // Spins until it reads the given value
diff --git a/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.rs b/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.rs
index 76a5e6a0b6240..49df267c4c3e2 100644
--- a/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.rs
+++ b/src/tools/miri/tests/fail/stacked_borrows/illegal_dealloc1.rs
@@ -1,4 +1,4 @@
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 
 fn main() {
     unsafe {
diff --git a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.rs b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.rs
index b5a01cd4324e2..036267dc11e9d 100644
--- a/src/tools/miri/tests/fail/tree_borrows/children-can-alias.rs
+++ b/src/tools/miri/tests/fail/tree_borrows/children-can-alias.rs
@@ -8,8 +8,8 @@
 
 #![feature(ptr_internals)]
 
-use core::ptr::addr_of_mut;
 use core::ptr::Unique;
+use core::ptr::addr_of_mut;
 
 fn main() {
     let mut data = 0u8;
diff --git a/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic.rs b/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic.rs
index 8deaa30d50ff2..5edf4bbb1ccda 100644
--- a/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic.rs
+++ b/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic.rs
@@ -3,7 +3,7 @@
 
 #![allow(dropping_copy_types)]
 
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 use std::slice::from_raw_parts;
 
 fn main() {
diff --git a/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic_with_provenance.rs b/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic_with_provenance.rs
index adabff4a2cea2..954571f4a22cf 100644
--- a/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic_with_provenance.rs
+++ b/src/tools/miri/tests/fail/uninit/uninit_alloc_diagnostic_with_provenance.rs
@@ -6,7 +6,7 @@
 
 // Test printing allocations that contain single-byte provenance.
 
-use std::alloc::{alloc, dealloc, Layout};
+use std::alloc::{Layout, alloc, dealloc};
 use std::mem::{self, MaybeUninit};
 use std::slice::from_raw_parts;
 
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs
index afcab7a702deb..6853395686aa9 100644
--- a/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs
+++ b/src/tools/miri/tests/pass-dep/concurrency/windows_init_once.rs
@@ -7,7 +7,7 @@ use std::thread;
 
 use windows_sys::Win32::Foundation::{FALSE, TRUE};
 use windows_sys::Win32::System::Threading::{
-    InitOnceBeginInitialize, InitOnceComplete, INIT_ONCE, INIT_ONCE_INIT_FAILED,
+    INIT_ONCE, INIT_ONCE_INIT_FAILED, InitOnceBeginInitialize, InitOnceComplete,
 };
 
 // not in windows-sys
diff --git a/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs b/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs
index 67e77663110e6..ce829eee22704 100644
--- a/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs
+++ b/src/tools/miri/tests/pass-dep/concurrency/windows_join_multiple.rs
@@ -7,7 +7,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 
 use windows_sys::Win32::Foundation::{HANDLE, WAIT_OBJECT_0};
-use windows_sys::Win32::System::Threading::{WaitForSingleObject, INFINITE};
+use windows_sys::Win32::System::Threading::{INFINITE, WaitForSingleObject};
 
 fn main() {
     static FLAG: AtomicBool = AtomicBool::new(false);
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs
index 2f65ce13d646b..3ea345133769b 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll-no-blocking.rs
@@ -231,10 +231,10 @@ fn test_two_same_fd_in_same_epoll_instance() {
     //Two notification should be received.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = 5 as u64;
-    check_epoll_wait::<8>(
-        epfd,
-        &[(expected_event, expected_value), (expected_event, expected_value)],
-    );
+    check_epoll_wait::<8>(epfd, &[
+        (expected_event, expected_value),
+        (expected_event, expected_value),
+    ]);
 }
 
 fn test_epoll_eventfd() {
@@ -291,10 +291,10 @@ fn test_epoll_socketpair_both_sides() {
     let expected_value0 = fds[0] as u64;
     let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value1 = fds[1] as u64;
-    check_epoll_wait::<8>(
-        epfd,
-        &[(expected_event0, expected_value0), (expected_event1, expected_value1)],
-    );
+    check_epoll_wait::<8>(epfd, &[
+        (expected_event0, expected_value0),
+        (expected_event1, expected_value1),
+    ]);
 
     // Read from fds[0].
     let mut buf: [u8; 5] = [0; 5];
@@ -454,10 +454,10 @@ fn test_socketpair_read() {
     let expected_value0 = fds[0] as u64;
     let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value1 = fds[1] as u64;
-    check_epoll_wait::<8>(
-        epfd,
-        &[(expected_event0, expected_value0), (expected_event1, expected_value1)],
-    );
+    check_epoll_wait::<8>(epfd, &[
+        (expected_event0, expected_value0),
+        (expected_event1, expected_value1),
+    ]);
 
     // Read 3 bytes from fds[0].
     let mut buf: [u8; 3] = [0; 3];
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
index 1180961374946..17e6e507c2750 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-fs.rs
@@ -5,7 +5,7 @@
 #![feature(io_error_uncategorized)]
 
 use std::ffi::{CStr, CString, OsString};
-use std::fs::{canonicalize, remove_file, File};
+use std::fs::{File, canonicalize, remove_file};
 use std::io::{Error, ErrorKind, Write};
 use std::os::unix::ffi::OsStrExt;
 use std::os::unix::io::AsRawFd;
@@ -169,7 +169,7 @@ fn test_ftruncate<T: From<i32>>(
 
 #[cfg(target_os = "linux")]
 fn test_o_tmpfile_flag() {
-    use std::fs::{create_dir, OpenOptions};
+    use std::fs::{OpenOptions, create_dir};
     use std::os::unix::fs::OpenOptionsExt;
     let dir_path = utils::prepare_dir("miri_test_fs_dir");
     create_dir(&dir_path).unwrap();
diff --git a/src/tools/miri/tests/pass-dep/tokio/sleep.rs b/src/tools/miri/tests/pass-dep/tokio/sleep.rs
index 38f2cdde115d8..3c409a641f225 100644
--- a/src/tools/miri/tests/pass-dep/tokio/sleep.rs
+++ b/src/tools/miri/tests/pass-dep/tokio/sleep.rs
@@ -1,6 +1,6 @@
 //@only-target: linux # We only support tokio on Linux
 
-use tokio::time::{sleep, Duration, Instant};
+use tokio::time::{Duration, Instant, sleep};
 
 #[tokio::main]
 async fn main() {
diff --git a/src/tools/miri/tests/pass/0weak_memory_consistency.rs b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
index 1cbccb2eebdd8..10f7aed9418ab 100644
--- a/src/tools/miri/tests/pass/0weak_memory_consistency.rs
+++ b/src/tools/miri/tests/pass/0weak_memory_consistency.rs
@@ -22,7 +22,7 @@
 // Available: https://ss265.host.cs.st-andrews.ac.uk/papers/n3132.pdf.
 
 use std::sync::atomic::Ordering::*;
-use std::sync::atomic::{fence, AtomicBool, AtomicI32};
+use std::sync::atomic::{AtomicBool, AtomicI32, fence};
 use std::thread::spawn;
 
 #[derive(Copy, Clone)]
diff --git a/src/tools/miri/tests/pass/async-drop.rs b/src/tools/miri/tests/pass/async-drop.rs
index 92ecbdd29fdb9..53e3476f62040 100644
--- a/src/tools/miri/tests/pass/async-drop.rs
+++ b/src/tools/miri/tests/pass/async-drop.rs
@@ -10,10 +10,10 @@
 #![allow(incomplete_features, dead_code)]
 
 // FIXME(zetanumbers): consider AsyncDestruct::async_drop cleanup tests
-use core::future::{async_drop_in_place, AsyncDrop, Future};
+use core::future::{AsyncDrop, Future, async_drop_in_place};
 use core::hint::black_box;
 use core::mem::{self, ManuallyDrop};
-use core::pin::{pin, Pin};
+use core::pin::{Pin, pin};
 use core::task::{Context, Poll, Waker};
 
 async fn test_async_drop<T>(x: T) {
@@ -125,7 +125,10 @@ struct AsyncReference<'a> {
 }
 
 impl AsyncDrop for AsyncReference<'_> {
-    type Dropper<'a> = impl Future<Output = ()> where Self: 'a;
+    type Dropper<'a>
+        = impl Future<Output = ()>
+    where
+        Self: 'a;
 
     fn async_drop(self: Pin<&mut Self>) -> Self::Dropper<'_> {
         async move {
diff --git a/src/tools/miri/tests/pass/atomic.rs b/src/tools/miri/tests/pass/atomic.rs
index c03023ee6930b..781cc9bd30942 100644
--- a/src/tools/miri/tests/pass/atomic.rs
+++ b/src/tools/miri/tests/pass/atomic.rs
@@ -7,7 +7,7 @@
 #![allow(static_mut_refs)]
 
 use std::sync::atomic::{
-    compiler_fence, fence, AtomicBool, AtomicIsize, AtomicPtr, AtomicU64, Ordering::*,
+    AtomicBool, AtomicIsize, AtomicPtr, AtomicU64, Ordering::*, compiler_fence, fence,
 };
 
 fn main() {
diff --git a/src/tools/miri/tests/pass/box-custom-alloc-aliasing.rs b/src/tools/miri/tests/pass/box-custom-alloc-aliasing.rs
index 18980932f31cc..a1371242f60d9 100644
--- a/src/tools/miri/tests/pass/box-custom-alloc-aliasing.rs
+++ b/src/tools/miri/tests/pass/box-custom-alloc-aliasing.rs
@@ -11,7 +11,7 @@ use std::{
     alloc::{AllocError, Allocator, Layout},
     cell::{Cell, UnsafeCell},
     mem,
-    ptr::{self, addr_of, NonNull},
+    ptr::{self, NonNull, addr_of},
     thread::{self, ThreadId},
 };
 
diff --git a/src/tools/miri/tests/pass/catch.rs b/src/tools/miri/tests/pass/catch.rs
index 4ede23e68ce25..bedabf3eb286a 100644
--- a/src/tools/miri/tests/pass/catch.rs
+++ b/src/tools/miri/tests/pass/catch.rs
@@ -1,4 +1,4 @@
-use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::panic::{AssertUnwindSafe, catch_unwind};
 
 fn main() {
     let mut i = 3;
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index 4c0d6f52425cd..cd606a5282a98 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -11,7 +11,7 @@
 #![allow(incomplete_features, internal_features)]
 use std::intrinsics::simd as intrinsics;
 use std::ptr;
-use std::simd::{prelude::*, StdFloat};
+use std::simd::{StdFloat, prelude::*};
 
 extern "rust-intrinsic" {
     #[rustc_nounwind]
diff --git a/src/tools/miri/tests/pass/panic/catch_panic.rs b/src/tools/miri/tests/pass/panic/catch_panic.rs
index b83902a8b19a4..06d15a1a7f94e 100644
--- a/src/tools/miri/tests/pass/panic/catch_panic.rs
+++ b/src/tools/miri/tests/pass/panic/catch_panic.rs
@@ -2,7 +2,7 @@
 #![allow(unconditional_panic, non_fmt_panics)]
 
 use std::cell::Cell;
-use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::process;
 
 thread_local! {
diff --git a/src/tools/miri/tests/pass/panic/concurrent-panic.rs b/src/tools/miri/tests/pass/panic/concurrent-panic.rs
index 7cc1e2a973fd6..e804df90977a9 100644
--- a/src/tools/miri/tests/pass/panic/concurrent-panic.rs
+++ b/src/tools/miri/tests/pass/panic/concurrent-panic.rs
@@ -5,7 +5,7 @@
 //! that separate threads have their own panicking state.
 
 use std::sync::{Arc, Condvar, Mutex};
-use std::thread::{spawn, JoinHandle};
+use std::thread::{JoinHandle, spawn};
 
 struct BlockOnDrop(Option<JoinHandle<()>>);
 
diff --git a/src/tools/miri/tests/pass/path.rs b/src/tools/miri/tests/pass/path.rs
index fe99d38e073bf..299ee6cfe9dde 100644
--- a/src/tools/miri/tests/pass/path.rs
+++ b/src/tools/miri/tests/pass/path.rs
@@ -1,5 +1,5 @@
 //@compile-flags: -Zmiri-disable-isolation
-use std::path::{absolute, Path, PathBuf};
+use std::path::{Path, PathBuf, absolute};
 
 #[path = "../utils/mod.rs"]
 mod utils;
diff --git a/src/tools/miri/tests/pass/shims/fs-symlink.rs b/src/tools/miri/tests/pass/shims/fs-symlink.rs
index 01bb713926c65..30cf234e7a0d1 100644
--- a/src/tools/miri/tests/pass/shims/fs-symlink.rs
+++ b/src/tools/miri/tests/pass/shims/fs-symlink.rs
@@ -3,7 +3,7 @@
 //@ignore-target: windows # File handling is not implemented yet
 //@compile-flags: -Zmiri-disable-isolation
 
-use std::fs::{read_link, remove_file, File};
+use std::fs::{File, read_link, remove_file};
 use std::io::{Read, Result};
 use std::path::Path;
 
diff --git a/src/tools/miri/tests/pass/shims/fs.rs b/src/tools/miri/tests/pass/shims/fs.rs
index 761164a4ba375..62424ca26b1c7 100644
--- a/src/tools/miri/tests/pass/shims/fs.rs
+++ b/src/tools/miri/tests/pass/shims/fs.rs
@@ -7,8 +7,8 @@
 use std::collections::HashMap;
 use std::ffi::OsString;
 use std::fs::{
-    canonicalize, create_dir, read_dir, remove_dir, remove_dir_all, remove_file, rename, File,
-    OpenOptions,
+    File, OpenOptions, canonicalize, create_dir, read_dir, remove_dir, remove_dir_all, remove_file,
+    rename,
 };
 use std::io::{Error, ErrorKind, IsTerminal, Read, Result, Seek, SeekFrom, Write};
 use std::path::Path;
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
index a62a5ee3781b7..6f7ab3b3c9fb9 100644
--- a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs
@@ -1,1107 +1,1088 @@
+// We're testing x86 target specific features
+//@only-target: x86_64 i686
+
+#[cfg(target_arch = "x86")]
+use std::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+use std::f32::NAN;
+use std::mem::transmute;
+
 fn main() {
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    {
-        assert!(is_x86_feature_detected!("sse"));
+    assert!(is_x86_feature_detected!("sse"));
 
-        unsafe {
-            tests::test_sse();
-        }
+    unsafe {
+        test_sse();
     }
 }
 
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-mod tests {
-    #[cfg(target_arch = "x86")]
-    use std::arch::x86::*;
-    #[cfg(target_arch = "x86_64")]
-    use std::arch::x86_64::*;
-    use std::f32::NAN;
-    use std::mem::transmute;
-
-    macro_rules! assert_approx_eq {
-        ($a:expr, $b:expr, $eps:expr) => {{
-            let (a, b) = (&$a, &$b);
-            assert!(
-                (*a - *b).abs() < $eps,
-                "assertion failed: `(left !== right)` \
+macro_rules! assert_approx_eq {
+    ($a:expr, $b:expr, $eps:expr) => {{
+        let (a, b) = (&$a, &$b);
+        assert!(
+            (*a - *b).abs() < $eps,
+            "assertion failed: `(left !== right)` \
              (left: `{:?}`, right: `{:?}`, expect diff: `{:?}`, real diff: `{:?}`)",
-                *a,
-                *b,
-                $eps,
-                (*a - *b).abs()
-            );
-        }};
-    }
+            *a,
+            *b,
+            $eps,
+            (*a - *b).abs()
+        );
+    }};
+}
+
+#[target_feature(enable = "sse")]
+unsafe fn test_sse() {
+    // Mostly copied from library/stdarch/crates/core_arch/src/x86{,_64}/sse.rs
 
     #[target_feature(enable = "sse")]
-    pub(super) unsafe fn test_sse() {
-        // Mostly copied from library/stdarch/crates/core_arch/src/x86{,_64}/sse.rs
-
-        #[target_feature(enable = "sse")]
-        unsafe fn assert_eq_m128(a: __m128, b: __m128) {
-            let r = _mm_cmpeq_ps(a, b);
-            if _mm_movemask_ps(r) != 0b1111 {
-                panic!("{:?} != {:?}", a, b);
-            }
+    unsafe fn assert_eq_m128(a: __m128, b: __m128) {
+        let r = _mm_cmpeq_ps(a, b);
+        if _mm_movemask_ps(r) != 0b1111 {
+            panic!("{:?} != {:?}", a, b);
         }
+    }
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_add_ss() {
-            let a = _mm_set_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_set_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_add_ss(a, b);
-            assert_eq_m128(r, _mm_set_ps(-1.0, 5.0, 0.0, -15.0));
-        }
-        test_mm_add_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_sub_ss() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_sub_ss(a, b);
-            assert_eq_m128(r, _mm_setr_ps(99.0, 5.0, 0.0, -10.0));
-        }
-        test_mm_sub_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_mul_ss() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_mul_ss(a, b);
-            assert_eq_m128(r, _mm_setr_ps(100.0, 5.0, 0.0, -10.0));
-        }
-        test_mm_mul_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_div_ss() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_div_ss(a, b);
-            assert_eq_m128(r, _mm_setr_ps(0.01, 5.0, 0.0, -10.0));
-        }
-        test_mm_div_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_sqrt_ss() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_sqrt_ss(a);
-            let e = _mm_setr_ps(2.0, 13.0, 16.0, 100.0);
-            assert_eq_m128(r, e);
-        }
-        test_mm_sqrt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_sqrt_ps() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_sqrt_ps(a);
-            let e = _mm_setr_ps(2.0, 3.6055512, 4.0, 10.0);
-            assert_eq_m128(r, e);
-        }
-        test_mm_sqrt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_rcp_ss() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_rcp_ss(a);
-            let e = _mm_setr_ps(0.24993896, 13.0, 16.0, 100.0);
-            let rel_err = 0.00048828125;
-
-            let r: [f32; 4] = transmute(r);
-            let e: [f32; 4] = transmute(e);
-            assert_approx_eq!(r[0], e[0], 2. * rel_err);
-            for i in 1..4 {
-                assert_eq!(r[i], e[i]);
-            }
-        }
-        test_mm_rcp_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_rcp_ps() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_rcp_ps(a);
-            let e = _mm_setr_ps(0.24993896, 0.0769043, 0.06248474, 0.0099983215);
-            let rel_err = 0.00048828125;
-
-            let r: [f32; 4] = transmute(r);
-            let e: [f32; 4] = transmute(e);
-            for i in 0..4 {
-                assert_approx_eq!(r[i], e[i], 2. * rel_err);
-            }
-        }
-        test_mm_rcp_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_rsqrt_ss() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_rsqrt_ss(a);
-            let e = _mm_setr_ps(0.49987793, 13.0, 16.0, 100.0);
-            let rel_err = 0.00048828125;
-
-            let r: [f32; 4] = transmute(r);
-            let e: [f32; 4] = transmute(e);
-            assert_approx_eq!(r[0], e[0], 2. * rel_err);
-            for i in 1..4 {
-                assert_eq!(r[i], e[i]);
-            }
-        }
-        test_mm_rsqrt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_rsqrt_ps() {
-            let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
-            let r = _mm_rsqrt_ps(a);
-            let e = _mm_setr_ps(0.49987793, 0.2772827, 0.24993896, 0.099990845);
-            let rel_err = 0.00048828125;
-
-            let r: [f32; 4] = transmute(r);
-            let e: [f32; 4] = transmute(e);
-            for i in 0..4 {
-                assert_approx_eq!(r[i], e[i], 2. * rel_err);
-            }
-        }
-        test_mm_rsqrt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_min_ss() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_min_ss(a, b);
-            assert_eq_m128(r, _mm_setr_ps(-100.0, 5.0, 0.0, -10.0));
-        }
-        test_mm_min_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_min_ps() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_min_ps(a, b);
-            assert_eq_m128(r, _mm_setr_ps(-100.0, 5.0, 0.0, -10.0));
-
-            // `_mm_min_ps` can **not** be implemented using the `simd_min` rust intrinsic because
-            // the semantics of `simd_min` are different to those of `_mm_min_ps` regarding handling
-            // of `-0.0`.
-            let a = _mm_setr_ps(-0.0, 0.0, 0.0, 0.0);
-            let b = _mm_setr_ps(0.0, 0.0, 0.0, 0.0);
-            let r1: [u8; 16] = transmute(_mm_min_ps(a, b));
-            let r2: [u8; 16] = transmute(_mm_min_ps(b, a));
-            let a: [u8; 16] = transmute(a);
-            let b: [u8; 16] = transmute(b);
-            assert_eq!(r1, b);
-            assert_eq!(r2, a);
-            assert_ne!(a, b); // sanity check that -0.0 is actually present
-        }
-        test_mm_min_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_max_ss() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_max_ss(a, b);
-            assert_eq_m128(r, _mm_setr_ps(-1.0, 5.0, 0.0, -10.0));
-        }
-        test_mm_max_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_max_ps() {
-            let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
-            let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
-            let r = _mm_max_ps(a, b);
-            assert_eq_m128(r, _mm_setr_ps(-1.0, 20.0, 0.0, -5.0));
-
-            // `_mm_max_ps` can **not** be implemented using the `simd_max` rust intrinsic because
-            // the semantics of `simd_max` are different to those of `_mm_max_ps` regarding handling
-            // of `-0.0`.
-            let a = _mm_setr_ps(-0.0, 0.0, 0.0, 0.0);
-            let b = _mm_setr_ps(0.0, 0.0, 0.0, 0.0);
-            let r1: [u8; 16] = transmute(_mm_max_ps(a, b));
-            let r2: [u8; 16] = transmute(_mm_max_ps(b, a));
-            let a: [u8; 16] = transmute(a);
-            let b: [u8; 16] = transmute(b);
-            assert_eq!(r1, b);
-            assert_eq!(r2, a);
-            assert_ne!(a, b); // sanity check that -0.0 is actually present
-        }
-        test_mm_max_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpeq_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(-1.0, 5.0, 6.0, 7.0);
-            let r: [u32; 4] = transmute(_mm_cmpeq_ss(a, b));
-            let e: [u32; 4] = transmute(_mm_setr_ps(transmute(0u32), 2.0, 3.0, 4.0));
-            assert_eq!(r, e);
-
-            let b2 = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let r2: [u32; 4] = transmute(_mm_cmpeq_ss(a, b2));
-            let e2: [u32; 4] = transmute(_mm_setr_ps(transmute(0xffffffffu32), 2.0, 3.0, 4.0));
-            assert_eq!(r2, e2);
-        }
-        test_mm_cmpeq_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmplt_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = 0u32; // a.extract(0) < b.extract(0)
-            let c1 = 0u32; // a.extract(0) < c.extract(0)
-            let d1 = !0u32; // a.extract(0) < d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmplt_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmplt_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmplt_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmplt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmple_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = 0u32; // a.extract(0) <= b.extract(0)
-            let c1 = !0u32; // a.extract(0) <= c.extract(0)
-            let d1 = !0u32; // a.extract(0) <= d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmple_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmple_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmple_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmple_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpgt_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) > b.extract(0)
-            let c1 = 0u32; // a.extract(0) > c.extract(0)
-            let d1 = 0u32; // a.extract(0) > d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpgt_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpgt_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpgt_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpgt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpge_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) >= b.extract(0)
-            let c1 = !0u32; // a.extract(0) >= c.extract(0)
-            let d1 = 0u32; // a.extract(0) >= d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpge_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpge_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpge_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpge_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpneq_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) != b.extract(0)
-            let c1 = 0u32; // a.extract(0) != c.extract(0)
-            let d1 = !0u32; // a.extract(0) != d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpneq_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpneq_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpneq_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpneq_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnlt_ss() {
-            // TODO: this test is exactly the same as for `_mm_cmpge_ss`, but there
-            // must be a difference. It may have to do with behavior in the
-            // presence of NaNs (signaling or quiet). If so, we should add tests
-            // for those.
-
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) >= b.extract(0)
-            let c1 = !0u32; // a.extract(0) >= c.extract(0)
-            let d1 = 0u32; // a.extract(0) >= d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpnlt_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpnlt_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpnlt_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpnlt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnle_ss() {
-            // TODO: this test is exactly the same as for `_mm_cmpgt_ss`, but there
-            // must be a difference. It may have to do with behavior in the
-            // presence
-            // of NaNs (signaling or quiet). If so, we should add tests for those.
-
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) > b.extract(0)
-            let c1 = 0u32; // a.extract(0) > c.extract(0)
-            let d1 = 0u32; // a.extract(0) > d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpnle_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpnle_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpnle_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpnle_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpngt_ss() {
-            // TODO: this test is exactly the same as for `_mm_cmple_ss`, but there
-            // must be a difference. It may have to do with behavior in the
-            // presence of NaNs (signaling or quiet). If so, we should add tests
-            // for those.
-
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = 0u32; // a.extract(0) <= b.extract(0)
-            let c1 = !0u32; // a.extract(0) <= c.extract(0)
-            let d1 = !0u32; // a.extract(0) <= d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpngt_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpngt_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpngt_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpngt_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnge_ss() {
-            // TODO: this test is exactly the same as for `_mm_cmplt_ss`, but there
-            // must be a difference. It may have to do with behavior in the
-            // presence of NaNs (signaling or quiet). If so, we should add tests
-            // for those.
-
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = 0u32; // a.extract(0) < b.extract(0)
-            let c1 = 0u32; // a.extract(0) < c.extract(0)
-            let d1 = !0u32; // a.extract(0) < d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpnge_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpnge_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpnge_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpnge_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpord_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(NAN, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = !0u32; // a.extract(0) ord b.extract(0)
-            let c1 = 0u32; // a.extract(0) ord c.extract(0)
-            let d1 = !0u32; // a.extract(0) ord d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpord_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpord_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpord_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpord_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpunord_ss() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
-            let c = _mm_setr_ps(NAN, 5.0, 6.0, 7.0);
-            let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
-
-            let b1 = 0u32; // a.extract(0) unord b.extract(0)
-            let c1 = !0u32; // a.extract(0) unord c.extract(0)
-            let d1 = 0u32; // a.extract(0) unord d.extract(0)
-
-            let rb: [u32; 4] = transmute(_mm_cmpunord_ss(a, b));
-            let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
-            assert_eq!(rb, eb);
-
-            let rc: [u32; 4] = transmute(_mm_cmpunord_ss(a, c));
-            let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
-            assert_eq!(rc, ec);
-
-            let rd: [u32; 4] = transmute(_mm_cmpunord_ss(a, d));
-            let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
-            assert_eq!(rd, ed);
-        }
-        test_mm_cmpunord_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpeq_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, fls, tru, fls];
-            let r: [u32; 4] = transmute(_mm_cmpeq_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpeq_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmplt_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, fls, fls, fls];
-            let r: [u32; 4] = transmute(_mm_cmplt_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmplt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmple_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, 4.0);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, fls, tru, fls];
-            let r: [u32; 4] = transmute(_mm_cmple_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmple_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpgt_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 42.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, tru, fls, fls];
-            let r: [u32; 4] = transmute(_mm_cmpgt_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpgt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpge_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 42.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, tru, tru, fls];
-            let r: [u32; 4] = transmute(_mm_cmpge_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpge_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpneq_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, tru, fls, tru];
-            let r: [u32; 4] = transmute(_mm_cmpneq_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpneq_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnlt_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, tru, tru, tru];
-            let r: [u32; 4] = transmute(_mm_cmpnlt_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpnlt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnle_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, tru, fls, tru];
-            let r: [u32; 4] = transmute(_mm_cmpnle_ps(a, b));
-            assert_eq!(r, e);
-        }
-        test_mm_cmpnle_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpngt_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, fls, tru, tru];
-            let r: [u32; 4] = transmute(_mm_cmpngt_ps(a, b));
-            assert_eq!(r, e);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_add_ss() {
+        let a = _mm_set_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_set_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_add_ss(a, b);
+        assert_eq_m128(r, _mm_set_ps(-1.0, 5.0, 0.0, -15.0));
+    }
+    test_mm_add_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_sub_ss() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_sub_ss(a, b);
+        assert_eq_m128(r, _mm_setr_ps(99.0, 5.0, 0.0, -10.0));
+    }
+    test_mm_sub_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_mul_ss() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_mul_ss(a, b);
+        assert_eq_m128(r, _mm_setr_ps(100.0, 5.0, 0.0, -10.0));
+    }
+    test_mm_mul_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_div_ss() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_div_ss(a, b);
+        assert_eq_m128(r, _mm_setr_ps(0.01, 5.0, 0.0, -10.0));
+    }
+    test_mm_div_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_sqrt_ss() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_sqrt_ss(a);
+        let e = _mm_setr_ps(2.0, 13.0, 16.0, 100.0);
+        assert_eq_m128(r, e);
+    }
+    test_mm_sqrt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_sqrt_ps() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_sqrt_ps(a);
+        let e = _mm_setr_ps(2.0, 3.6055512, 4.0, 10.0);
+        assert_eq_m128(r, e);
+    }
+    test_mm_sqrt_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_rcp_ss() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_rcp_ss(a);
+        let e = _mm_setr_ps(0.24993896, 13.0, 16.0, 100.0);
+        let rel_err = 0.00048828125;
+
+        let r: [f32; 4] = transmute(r);
+        let e: [f32; 4] = transmute(e);
+        assert_approx_eq!(r[0], e[0], 2. * rel_err);
+        for i in 1..4 {
+            assert_eq!(r[i], e[i]);
         }
-        test_mm_cmpngt_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpnge_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
-            let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, fls, fls, tru];
-            let r: [u32; 4] = transmute(_mm_cmpnge_ps(a, b));
-            assert_eq!(r, e);
+    }
+    test_mm_rcp_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_rcp_ps() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_rcp_ps(a);
+        let e = _mm_setr_ps(0.24993896, 0.0769043, 0.06248474, 0.0099983215);
+        let rel_err = 0.00048828125;
+
+        let r: [f32; 4] = transmute(r);
+        let e: [f32; 4] = transmute(e);
+        for i in 0..4 {
+            assert_approx_eq!(r[i], e[i], 2. * rel_err);
         }
-        test_mm_cmpnge_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpord_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, NAN, NAN);
-            let b = _mm_setr_ps(15.0, NAN, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [tru, fls, fls, fls];
-            let r: [u32; 4] = transmute(_mm_cmpord_ps(a, b));
-            assert_eq!(r, e);
+    }
+    test_mm_rcp_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_rsqrt_ss() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_rsqrt_ss(a);
+        let e = _mm_setr_ps(0.49987793, 13.0, 16.0, 100.0);
+        let rel_err = 0.00048828125;
+
+        let r: [f32; 4] = transmute(r);
+        let e: [f32; 4] = transmute(e);
+        assert_approx_eq!(r[0], e[0], 2. * rel_err);
+        for i in 1..4 {
+            assert_eq!(r[i], e[i]);
         }
-        test_mm_cmpord_ps();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cmpunord_ps() {
-            let a = _mm_setr_ps(10.0, 50.0, NAN, NAN);
-            let b = _mm_setr_ps(15.0, NAN, 1.0, NAN);
-            let tru = !0u32;
-            let fls = 0u32;
-
-            let e = [fls, tru, tru, tru];
-            let r: [u32; 4] = transmute(_mm_cmpunord_ps(a, b));
-            assert_eq!(r, e);
+    }
+    test_mm_rsqrt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_rsqrt_ps() {
+        let a = _mm_setr_ps(4.0, 13.0, 16.0, 100.0);
+        let r = _mm_rsqrt_ps(a);
+        let e = _mm_setr_ps(0.49987793, 0.2772827, 0.24993896, 0.099990845);
+        let rel_err = 0.00048828125;
+
+        let r: [f32; 4] = transmute(r);
+        let e: [f32; 4] = transmute(e);
+        for i in 0..4 {
+            assert_approx_eq!(r[i], e[i], 2. * rel_err);
         }
-        test_mm_cmpunord_ps();
+    }
+    test_mm_rsqrt_ps();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_comieq_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_min_ss() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_min_ss(a, b);
+        assert_eq_m128(r, _mm_setr_ps(-100.0, 5.0, 0.0, -10.0));
+    }
+    test_mm_min_ss();
 
-            let ee = &[1i32, 0, 0, 0];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_min_ps() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_min_ps(a, b);
+        assert_eq_m128(r, _mm_setr_ps(-100.0, 5.0, 0.0, -10.0));
+
+        // `_mm_min_ps` can **not** be implemented using the `simd_min` rust intrinsic because
+        // the semantics of `simd_min` are different to those of `_mm_min_ps` regarding handling
+        // of `-0.0`.
+        let a = _mm_setr_ps(-0.0, 0.0, 0.0, 0.0);
+        let b = _mm_setr_ps(0.0, 0.0, 0.0, 0.0);
+        let r1: [u8; 16] = transmute(_mm_min_ps(a, b));
+        let r2: [u8; 16] = transmute(_mm_min_ps(b, a));
+        let a: [u8; 16] = transmute(a);
+        let b: [u8; 16] = transmute(b);
+        assert_eq!(r1, b);
+        assert_eq!(r2, a);
+        assert_ne!(a, b); // sanity check that -0.0 is actually present
+    }
+    test_mm_min_ps();
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_max_ss() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_max_ss(a, b);
+        assert_eq_m128(r, _mm_setr_ps(-1.0, 5.0, 0.0, -10.0));
+    }
+    test_mm_max_ss();
 
-                let r = _mm_comieq_ss(a, b);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_max_ps() {
+        let a = _mm_setr_ps(-1.0, 5.0, 0.0, -10.0);
+        let b = _mm_setr_ps(-100.0, 20.0, 0.0, -5.0);
+        let r = _mm_max_ps(a, b);
+        assert_eq_m128(r, _mm_setr_ps(-1.0, 20.0, 0.0, -5.0));
+
+        // `_mm_max_ps` can **not** be implemented using the `simd_max` rust intrinsic because
+        // the semantics of `simd_max` are different to those of `_mm_max_ps` regarding handling
+        // of `-0.0`.
+        let a = _mm_setr_ps(-0.0, 0.0, 0.0, 0.0);
+        let b = _mm_setr_ps(0.0, 0.0, 0.0, 0.0);
+        let r1: [u8; 16] = transmute(_mm_max_ps(a, b));
+        let r2: [u8; 16] = transmute(_mm_max_ps(b, a));
+        let a: [u8; 16] = transmute(a);
+        let b: [u8; 16] = transmute(b);
+        assert_eq!(r1, b);
+        assert_eq!(r2, a);
+        assert_ne!(a, b); // sanity check that -0.0 is actually present
+    }
+    test_mm_max_ps();
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_comieq_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
-        }
-        test_mm_comieq_ss();
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpeq_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(-1.0, 5.0, 6.0, 7.0);
+        let r: [u32; 4] = transmute(_mm_cmpeq_ss(a, b));
+        let e: [u32; 4] = transmute(_mm_setr_ps(transmute(0u32), 2.0, 3.0, 4.0));
+        assert_eq!(r, e);
+
+        let b2 = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let r2: [u32; 4] = transmute(_mm_cmpeq_ss(a, b2));
+        let e2: [u32; 4] = transmute(_mm_setr_ps(transmute(0xffffffffu32), 2.0, 3.0, 4.0));
+        assert_eq!(r2, e2);
+    }
+    test_mm_cmpeq_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmplt_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32; // a.extract(0) < b.extract(0)
+        let c1 = 0u32; // a.extract(0) < c.extract(0)
+        let d1 = !0u32; // a.extract(0) < d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmplt_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmplt_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmplt_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmplt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmple_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32; // a.extract(0) <= b.extract(0)
+        let c1 = !0u32; // a.extract(0) <= c.extract(0)
+        let d1 = !0u32; // a.extract(0) <= d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmple_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmple_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmple_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmple_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpgt_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) > b.extract(0)
+        let c1 = 0u32; // a.extract(0) > c.extract(0)
+        let d1 = 0u32; // a.extract(0) > d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpgt_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpgt_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpgt_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpgt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpge_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) >= b.extract(0)
+        let c1 = !0u32; // a.extract(0) >= c.extract(0)
+        let d1 = 0u32; // a.extract(0) >= d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpge_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpge_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpge_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpge_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpneq_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) != b.extract(0)
+        let c1 = 0u32; // a.extract(0) != c.extract(0)
+        let d1 = !0u32; // a.extract(0) != d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpneq_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpneq_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpneq_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpneq_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnlt_ss() {
+        // TODO: this test is exactly the same as for `_mm_cmpge_ss`, but there
+        // must be a difference. It may have to do with behavior in the
+        // presence of NaNs (signaling or quiet). If so, we should add tests
+        // for those.
+
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) >= b.extract(0)
+        let c1 = !0u32; // a.extract(0) >= c.extract(0)
+        let d1 = 0u32; // a.extract(0) >= d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpnlt_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpnlt_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpnlt_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpnlt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnle_ss() {
+        // TODO: this test is exactly the same as for `_mm_cmpgt_ss`, but there
+        // must be a difference. It may have to do with behavior in the
+        // presence
+        // of NaNs (signaling or quiet). If so, we should add tests for those.
+
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) > b.extract(0)
+        let c1 = 0u32; // a.extract(0) > c.extract(0)
+        let d1 = 0u32; // a.extract(0) > d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpnle_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpnle_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpnle_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpnle_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpngt_ss() {
+        // TODO: this test is exactly the same as for `_mm_cmple_ss`, but there
+        // must be a difference. It may have to do with behavior in the
+        // presence of NaNs (signaling or quiet). If so, we should add tests
+        // for those.
+
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32; // a.extract(0) <= b.extract(0)
+        let c1 = !0u32; // a.extract(0) <= c.extract(0)
+        let d1 = !0u32; // a.extract(0) <= d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpngt_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpngt_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpngt_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpngt_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnge_ss() {
+        // TODO: this test is exactly the same as for `_mm_cmplt_ss`, but there
+        // must be a difference. It may have to do with behavior in the
+        // presence of NaNs (signaling or quiet). If so, we should add tests
+        // for those.
+
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(1.0, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32; // a.extract(0) < b.extract(0)
+        let c1 = 0u32; // a.extract(0) < c.extract(0)
+        let d1 = !0u32; // a.extract(0) < d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpnge_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpnge_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpnge_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpnge_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpord_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(NAN, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = !0u32; // a.extract(0) ord b.extract(0)
+        let c1 = 0u32; // a.extract(0) ord c.extract(0)
+        let d1 = !0u32; // a.extract(0) ord d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpord_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpord_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpord_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpord_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpunord_ss() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let b = _mm_setr_ps(0.0, 5.0, 6.0, 7.0);
+        let c = _mm_setr_ps(NAN, 5.0, 6.0, 7.0);
+        let d = _mm_setr_ps(2.0, 5.0, 6.0, 7.0);
+
+        let b1 = 0u32; // a.extract(0) unord b.extract(0)
+        let c1 = !0u32; // a.extract(0) unord c.extract(0)
+        let d1 = 0u32; // a.extract(0) unord d.extract(0)
+
+        let rb: [u32; 4] = transmute(_mm_cmpunord_ss(a, b));
+        let eb: [u32; 4] = transmute(_mm_setr_ps(transmute(b1), 2.0, 3.0, 4.0));
+        assert_eq!(rb, eb);
+
+        let rc: [u32; 4] = transmute(_mm_cmpunord_ss(a, c));
+        let ec: [u32; 4] = transmute(_mm_setr_ps(transmute(c1), 2.0, 3.0, 4.0));
+        assert_eq!(rc, ec);
+
+        let rd: [u32; 4] = transmute(_mm_cmpunord_ss(a, d));
+        let ed: [u32; 4] = transmute(_mm_setr_ps(transmute(d1), 2.0, 3.0, 4.0));
+        assert_eq!(rd, ed);
+    }
+    test_mm_cmpunord_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpeq_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, fls, tru, fls];
+        let r: [u32; 4] = transmute(_mm_cmpeq_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpeq_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmplt_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, fls, fls, fls];
+        let r: [u32; 4] = transmute(_mm_cmplt_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmplt_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmple_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, 4.0);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, fls, tru, fls];
+        let r: [u32; 4] = transmute(_mm_cmple_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmple_ps();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_comilt_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpgt_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 42.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, tru, fls, fls];
+        let r: [u32; 4] = transmute(_mm_cmpgt_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpgt_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpge_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 42.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, tru, tru, fls];
+        let r: [u32; 4] = transmute(_mm_cmpge_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpge_ps();
 
-            let ee = &[0i32, 1, 0, 0];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpneq_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, tru, fls, tru];
+        let r: [u32; 4] = transmute(_mm_cmpneq_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpneq_ps();
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnlt_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, tru, tru, tru];
+        let r: [u32; 4] = transmute(_mm_cmpnlt_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpnlt_ps();
 
-                let r = _mm_comilt_ss(a, b);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnle_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, tru, fls, tru];
+        let r: [u32; 4] = transmute(_mm_cmpnle_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpnle_ps();
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_comilt_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpngt_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, fls, tru, tru];
+        let r: [u32; 4] = transmute(_mm_cmpngt_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpngt_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpnge_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, 1.0, NAN);
+        let b = _mm_setr_ps(15.0, 20.0, 1.0, 5.0);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, fls, fls, tru];
+        let r: [u32; 4] = transmute(_mm_cmpnge_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpnge_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpord_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, NAN, NAN);
+        let b = _mm_setr_ps(15.0, NAN, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [tru, fls, fls, fls];
+        let r: [u32; 4] = transmute(_mm_cmpord_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpord_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cmpunord_ps() {
+        let a = _mm_setr_ps(10.0, 50.0, NAN, NAN);
+        let b = _mm_setr_ps(15.0, NAN, 1.0, NAN);
+        let tru = !0u32;
+        let fls = 0u32;
+
+        let e = [fls, tru, tru, tru];
+        let r: [u32; 4] = transmute(_mm_cmpunord_ps(a, b));
+        assert_eq!(r, e);
+    }
+    test_mm_cmpunord_ps();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_comieq_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
+
+        let ee = &[1i32, 0, 0, 0];
+
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+
+            let r = _mm_comieq_ss(a, b);
+
+            assert_eq!(
+                ee[i], r,
+                "_mm_comieq_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_comilt_ss();
+    }
+    test_mm_comieq_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_comile_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_comilt_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[1i32, 1, 0, 0];
+        let ee = &[0i32, 1, 0, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_comile_ss(a, b);
+            let r = _mm_comilt_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_comile_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_comilt_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_comile_ss();
+    }
+    test_mm_comilt_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_comigt_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_comile_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[1i32, 0, 1, 0];
+        let ee = &[1i32, 1, 0, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_comige_ss(a, b);
+            let r = _mm_comile_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_comige_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_comile_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_comigt_ss();
+    }
+    test_mm_comile_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_comineq_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_comigt_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[0i32, 1, 1, 1];
+        let ee = &[1i32, 0, 1, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_comineq_ss(a, b);
+            let r = _mm_comige_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_comineq_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_comige_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_comineq_ss();
+    }
+    test_mm_comigt_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomieq_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_comineq_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[1i32, 0, 0, 0];
+        let ee = &[0i32, 1, 1, 1];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomieq_ss(a, b);
+            let r = _mm_comineq_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomieq_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_comineq_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomieq_ss();
+    }
+    test_mm_comineq_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomilt_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomieq_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[0i32, 1, 0, 0];
+        let ee = &[1i32, 0, 0, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomilt_ss(a, b);
+            let r = _mm_ucomieq_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomilt_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomieq_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomilt_ss();
+    }
+    test_mm_ucomieq_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomile_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomilt_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[1i32, 1, 0, 0];
+        let ee = &[0i32, 1, 0, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomile_ss(a, b);
+            let r = _mm_ucomilt_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomile_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomilt_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomile_ss();
+    }
+    test_mm_ucomilt_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomigt_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomile_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[0i32, 0, 1, 0];
+        let ee = &[1i32, 1, 0, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomigt_ss(a, b);
+            let r = _mm_ucomile_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomigt_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomile_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomigt_ss();
+    }
+    test_mm_ucomile_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomige_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomigt_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[1i32, 0, 1, 0];
+        let ee = &[0i32, 0, 1, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomige_ss(a, b);
+            let r = _mm_ucomigt_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomige_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomigt_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomige_ss();
+    }
+    test_mm_ucomigt_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_ucomineq_ss() {
-            let aa = &[3.0f32, 12.0, 23.0, NAN];
-            let bb = &[3.0f32, 47.5, 1.5, NAN];
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomige_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
 
-            let ee = &[0i32, 1, 1, 1];
+        let ee = &[1i32, 0, 1, 0];
 
-            for i in 0..4 {
-                let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
-                let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
 
-                let r = _mm_ucomineq_ss(a, b);
+            let r = _mm_ucomige_ss(a, b);
 
-                assert_eq!(
-                    ee[i], r,
-                    "_mm_ucomineq_ss({:?}, {:?}) = {}, expected: {} (i={})",
-                    a, b, r, ee[i], i
-                );
-            }
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomige_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_ucomineq_ss();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvtss_si32() {
-            let inputs = &[42.0f32, -3.1, 4.0e10, 4.0e-20, NAN, 2147483500.1];
-            let result = &[42i32, -3, i32::MIN, 0, i32::MIN, 2147483520];
-            for i in 0..inputs.len() {
-                let x = _mm_setr_ps(inputs[i], 1.0, 3.0, 4.0);
-                let e = result[i];
-                let r = _mm_cvtss_si32(x);
-                assert_eq!(
-                    e, r,
-                    "TestCase #{} _mm_cvtss_si32({:?}) = {}, expected: {}",
-                    i, x, r, e
-                );
-            }
+    }
+    test_mm_ucomige_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_ucomineq_ss() {
+        let aa = &[3.0f32, 12.0, 23.0, NAN];
+        let bb = &[3.0f32, 47.5, 1.5, NAN];
+
+        let ee = &[0i32, 1, 1, 1];
+
+        for i in 0..4 {
+            let a = _mm_setr_ps(aa[i], 1.0, 2.0, 3.0);
+            let b = _mm_setr_ps(bb[i], 0.0, 2.0, 4.0);
+
+            let r = _mm_ucomineq_ss(a, b);
+
+            assert_eq!(
+                ee[i], r,
+                "_mm_ucomineq_ss({:?}, {:?}) = {}, expected: {} (i={})",
+                a, b, r, ee[i], i
+            );
         }
-        test_mm_cvtss_si32();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvttss_si32() {
-            let inputs = &[
-                (42.0f32, 42i32),
-                (-31.4, -31),
-                (-33.5, -33),
-                (-34.5, -34),
-                (10.999, 10),
-                (-5.99, -5),
-                (4.0e10, i32::MIN),
-                (4.0e-10, 0),
-                (NAN, i32::MIN),
-                (2147483500.1, 2147483520),
-            ];
-            for i in 0..inputs.len() {
-                let (xi, e) = inputs[i];
-                let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
-                let r = _mm_cvttss_si32(x);
-                assert_eq!(
-                    e, r,
-                    "TestCase #{} _mm_cvttss_si32({:?}) = {}, expected: {}",
-                    i, x, r, e
-                );
-            }
+    }
+    test_mm_ucomineq_ss();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvtss_si32() {
+        let inputs = &[42.0f32, -3.1, 4.0e10, 4.0e-20, NAN, 2147483500.1];
+        let result = &[42i32, -3, i32::MIN, 0, i32::MIN, 2147483520];
+        for i in 0..inputs.len() {
+            let x = _mm_setr_ps(inputs[i], 1.0, 3.0, 4.0);
+            let e = result[i];
+            let r = _mm_cvtss_si32(x);
+            assert_eq!(e, r, "TestCase #{} _mm_cvtss_si32({:?}) = {}, expected: {}", i, x, r, e);
         }
-        test_mm_cvttss_si32();
+    }
+    test_mm_cvtss_si32();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvtss_f32() {
-            let a = _mm_setr_ps(312.0134, 5.0, 6.0, 7.0);
-            assert_eq!(_mm_cvtss_f32(a), 312.0134);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvttss_si32() {
+        let inputs = &[
+            (42.0f32, 42i32),
+            (-31.4, -31),
+            (-33.5, -33),
+            (-34.5, -34),
+            (10.999, 10),
+            (-5.99, -5),
+            (4.0e10, i32::MIN),
+            (4.0e-10, 0),
+            (NAN, i32::MIN),
+            (2147483500.1, 2147483520),
+        ];
+        for i in 0..inputs.len() {
+            let (xi, e) = inputs[i];
+            let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
+            let r = _mm_cvttss_si32(x);
+            assert_eq!(e, r, "TestCase #{} _mm_cvttss_si32({:?}) = {}, expected: {}", i, x, r, e);
         }
-        test_mm_cvtss_f32();
-
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvtsi32_ss() {
-            let inputs = &[
-                (4555i32, 4555.0f32),
-                (322223333, 322223330.0),
-                (-432, -432.0),
-                (-322223333, -322223330.0),
-            ];
-
-            for i in 0..inputs.len() {
-                let (x, f) = inputs[i];
-                let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
-                let r = _mm_cvtsi32_ss(a, x);
-                let e = _mm_setr_ps(f, 6.0, 7.0, 8.0);
-                assert_eq_m128(e, r);
-            }
+    }
+    test_mm_cvttss_si32();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvtss_f32() {
+        let a = _mm_setr_ps(312.0134, 5.0, 6.0, 7.0);
+        assert_eq!(_mm_cvtss_f32(a), 312.0134);
+    }
+    test_mm_cvtss_f32();
+
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvtsi32_ss() {
+        let inputs = &[
+            (4555i32, 4555.0f32),
+            (322223333, 322223330.0),
+            (-432, -432.0),
+            (-322223333, -322223330.0),
+        ];
+
+        for i in 0..inputs.len() {
+            let (x, f) = inputs[i];
+            let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
+            let r = _mm_cvtsi32_ss(a, x);
+            let e = _mm_setr_ps(f, 6.0, 7.0, 8.0);
+            assert_eq_m128(e, r);
         }
-        test_mm_cvtsi32_ss();
-
-        // Intrinsic only available on x86_64
-        #[cfg(target_arch = "x86_64")]
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvtss_si64() {
-            let inputs = &[
-                (42.0f32, 42i64),
-                (-31.4, -31),
-                (-33.5, -34),
-                (-34.5, -34),
-                (4.0e10, 40_000_000_000),
-                (4.0e-10, 0),
-                (f32::NAN, i64::MIN),
-                (2147483500.1, 2147483520),
-                (9.223371e18, 9223370937343148032),
-            ];
-            for i in 0..inputs.len() {
-                let (xi, e) = inputs[i];
-                let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
-                let r = _mm_cvtss_si64(x);
-                assert_eq!(
-                    e, r,
-                    "TestCase #{} _mm_cvtss_si64({:?}) = {}, expected: {}",
-                    i, x, r, e
-                );
-            }
+    }
+    test_mm_cvtsi32_ss();
+
+    // Intrinsic only available on x86_64
+    #[cfg(target_arch = "x86_64")]
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvtss_si64() {
+        let inputs = &[
+            (42.0f32, 42i64),
+            (-31.4, -31),
+            (-33.5, -34),
+            (-34.5, -34),
+            (4.0e10, 40_000_000_000),
+            (4.0e-10, 0),
+            (f32::NAN, i64::MIN),
+            (2147483500.1, 2147483520),
+            (9.223371e18, 9223370937343148032),
+        ];
+        for i in 0..inputs.len() {
+            let (xi, e) = inputs[i];
+            let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
+            let r = _mm_cvtss_si64(x);
+            assert_eq!(e, r, "TestCase #{} _mm_cvtss_si64({:?}) = {}, expected: {}", i, x, r, e);
         }
-        #[cfg(target_arch = "x86_64")]
-        test_mm_cvtss_si64();
-
-        // Intrinsic only available on x86_64
-        #[cfg(target_arch = "x86_64")]
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvttss_si64() {
-            let inputs = &[
-                (42.0f32, 42i64),
-                (-31.4, -31),
-                (-33.5, -33),
-                (-34.5, -34),
-                (10.999, 10),
-                (-5.99, -5),
-                (4.0e10, 40_000_000_000),
-                (4.0e-10, 0),
-                (f32::NAN, i64::MIN),
-                (2147483500.1, 2147483520),
-                (9.223371e18, 9223370937343148032),
-                (9.223372e18, i64::MIN),
-            ];
-            for i in 0..inputs.len() {
-                let (xi, e) = inputs[i];
-                let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
-                let r = _mm_cvttss_si64(x);
-                assert_eq!(
-                    e, r,
-                    "TestCase #{} _mm_cvttss_si64({:?}) = {}, expected: {}",
-                    i, x, r, e
-                );
-            }
+    }
+    #[cfg(target_arch = "x86_64")]
+    test_mm_cvtss_si64();
+
+    // Intrinsic only available on x86_64
+    #[cfg(target_arch = "x86_64")]
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvttss_si64() {
+        let inputs = &[
+            (42.0f32, 42i64),
+            (-31.4, -31),
+            (-33.5, -33),
+            (-34.5, -34),
+            (10.999, 10),
+            (-5.99, -5),
+            (4.0e10, 40_000_000_000),
+            (4.0e-10, 0),
+            (f32::NAN, i64::MIN),
+            (2147483500.1, 2147483520),
+            (9.223371e18, 9223370937343148032),
+            (9.223372e18, i64::MIN),
+        ];
+        for i in 0..inputs.len() {
+            let (xi, e) = inputs[i];
+            let x = _mm_setr_ps(xi, 1.0, 3.0, 4.0);
+            let r = _mm_cvttss_si64(x);
+            assert_eq!(e, r, "TestCase #{} _mm_cvttss_si64({:?}) = {}, expected: {}", i, x, r, e);
         }
-        #[cfg(target_arch = "x86_64")]
-        test_mm_cvttss_si64();
-
-        // Intrinsic only available on x86_64
-        #[cfg(target_arch = "x86_64")]
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_cvtsi64_ss() {
-            let inputs = &[
-                (4555i64, 4555.0f32),
-                (322223333, 322223330.0),
-                (-432, -432.0),
-                (-322223333, -322223330.0),
-                (9223372036854775807, 9.223372e18),
-                (-9223372036854775808, -9.223372e18),
-            ];
-
-            for i in 0..inputs.len() {
-                let (x, f) = inputs[i];
-                let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
-                let r = _mm_cvtsi64_ss(a, x);
-                let e = _mm_setr_ps(f, 6.0, 7.0, 8.0);
-                assert_eq_m128(e, r);
-            }
+    }
+    #[cfg(target_arch = "x86_64")]
+    test_mm_cvttss_si64();
+
+    // Intrinsic only available on x86_64
+    #[cfg(target_arch = "x86_64")]
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_cvtsi64_ss() {
+        let inputs = &[
+            (4555i64, 4555.0f32),
+            (322223333, 322223330.0),
+            (-432, -432.0),
+            (-322223333, -322223330.0),
+            (9223372036854775807, 9.223372e18),
+            (-9223372036854775808, -9.223372e18),
+        ];
+
+        for i in 0..inputs.len() {
+            let (x, f) = inputs[i];
+            let a = _mm_setr_ps(5.0, 6.0, 7.0, 8.0);
+            let r = _mm_cvtsi64_ss(a, x);
+            let e = _mm_setr_ps(f, 6.0, 7.0, 8.0);
+            assert_eq_m128(e, r);
         }
-        #[cfg(target_arch = "x86_64")]
-        test_mm_cvtsi64_ss();
+    }
+    #[cfg(target_arch = "x86_64")]
+    test_mm_cvtsi64_ss();
 
-        #[target_feature(enable = "sse")]
-        unsafe fn test_mm_movemask_ps() {
-            let r = _mm_movemask_ps(_mm_setr_ps(-1.0, 5.0, -5.0, 0.0));
-            assert_eq!(r, 0b0101);
+    #[target_feature(enable = "sse")]
+    unsafe fn test_mm_movemask_ps() {
+        let r = _mm_movemask_ps(_mm_setr_ps(-1.0, 5.0, -5.0, 0.0));
+        assert_eq!(r, 0b0101);
 
-            let r = _mm_movemask_ps(_mm_setr_ps(-1.0, -5.0, -5.0, 0.0));
-            assert_eq!(r, 0b0111);
-        }
-        test_mm_movemask_ps();
-
-        let x = 0i8;
-        _mm_prefetch(&x, _MM_HINT_T0);
-        _mm_prefetch(&x, _MM_HINT_T1);
-        _mm_prefetch(&x, _MM_HINT_T2);
-        _mm_prefetch(&x, _MM_HINT_NTA);
-        _mm_prefetch(&x, _MM_HINT_ET0);
-        _mm_prefetch(&x, _MM_HINT_ET1);
+        let r = _mm_movemask_ps(_mm_setr_ps(-1.0, -5.0, -5.0, 0.0));
+        assert_eq!(r, 0b0111);
     }
+    test_mm_movemask_ps();
+
+    let x = 0i8;
+    _mm_prefetch(&x, _MM_HINT_T0);
+    _mm_prefetch(&x, _MM_HINT_T1);
+    _mm_prefetch(&x, _MM_HINT_T2);
+    _mm_prefetch(&x, _MM_HINT_NTA);
+    _mm_prefetch(&x, _MM_HINT_ET0);
+    _mm_prefetch(&x, _MM_HINT_ET1);
 }
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
index e0088b9eb24d3..7aaf9c2624f9c 100644
--- a/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse2.rs
@@ -1,848 +1,843 @@
+// We're testing x86 target specific features
+//@only-target: x86_64 i686
+
+#[cfg(target_arch = "x86")]
+use std::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+use std::f64::NAN;
+use std::mem::transmute;
+
 fn main() {
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    {
-        assert!(is_x86_feature_detected!("sse2"));
+    assert!(is_x86_feature_detected!("sse2"));
 
-        unsafe {
-            tests::test_sse2();
-        }
+    unsafe {
+        test_sse2();
     }
 }
 
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-mod tests {
-    #[cfg(target_arch = "x86")]
-    use std::arch::x86::*;
-    #[cfg(target_arch = "x86_64")]
-    use std::arch::x86_64::*;
-    use std::f64::NAN;
-    use std::mem::transmute;
+#[target_feature(enable = "sse2")]
+unsafe fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
+    _mm_set_epi64x(b, a)
+}
+
+#[target_feature(enable = "sse2")]
+unsafe fn test_sse2() {
+    // Mostly copied from library/stdarch/crates/core_arch/src/x86{,_64}/sse2.rs
 
-    #[target_feature(enable = "sse2")]
     unsafe fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
         _mm_set_epi64x(b, a)
     }
 
-    #[target_feature(enable = "sse2")]
-    pub(super) unsafe fn test_sse2() {
-        // Mostly copied from library/stdarch/crates/core_arch/src/x86{,_64}/sse2.rs
-
-        unsafe fn _mm_setr_epi64x(a: i64, b: i64) -> __m128i {
-            _mm_set_epi64x(b, a)
+    #[track_caller]
+    #[target_feature(enable = "sse")]
+    unsafe fn assert_eq_m128(a: __m128, b: __m128) {
+        let r = _mm_cmpeq_ps(a, b);
+        if _mm_movemask_ps(r) != 0b1111 {
+            panic!("{:?} != {:?}", a, b);
         }
+    }
 
-        #[track_caller]
-        #[target_feature(enable = "sse")]
-        unsafe fn assert_eq_m128(a: __m128, b: __m128) {
-            let r = _mm_cmpeq_ps(a, b);
-            if _mm_movemask_ps(r) != 0b1111 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        }
+    #[track_caller]
+    #[target_feature(enable = "sse2")]
+    unsafe fn assert_eq_m128i(a: __m128i, b: __m128i) {
+        assert_eq!(transmute::<_, [u64; 2]>(a), transmute::<_, [u64; 2]>(b))
+    }
 
-        #[track_caller]
-        #[target_feature(enable = "sse2")]
-        unsafe fn assert_eq_m128i(a: __m128i, b: __m128i) {
-            assert_eq!(transmute::<_, [u64; 2]>(a), transmute::<_, [u64; 2]>(b))
+    #[track_caller]
+    #[target_feature(enable = "sse2")]
+    unsafe fn assert_eq_m128d(a: __m128d, b: __m128d) {
+        if _mm_movemask_pd(_mm_cmpeq_pd(a, b)) != 0b11 {
+            panic!("{:?} != {:?}", a, b);
         }
+    }
 
-        #[track_caller]
-        #[target_feature(enable = "sse2")]
-        unsafe fn assert_eq_m128d(a: __m128d, b: __m128d) {
-            if _mm_movemask_pd(_mm_cmpeq_pd(a, b)) != 0b11 {
-                panic!("{:?} != {:?}", a, b);
-            }
-        }
+    fn test_mm_pause() {
+        unsafe { _mm_pause() }
+    }
+    test_mm_pause();
 
-        fn test_mm_pause() {
-            unsafe { _mm_pause() }
-        }
-        test_mm_pause();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_avg_epu8() {
+        let (a, b) = (_mm_set1_epi8(3), _mm_set1_epi8(9));
+        let r = _mm_avg_epu8(a, b);
+        assert_eq_m128i(r, _mm_set1_epi8(6));
+    }
+    test_mm_avg_epu8();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_avg_epu8() {
-            let (a, b) = (_mm_set1_epi8(3), _mm_set1_epi8(9));
-            let r = _mm_avg_epu8(a, b);
-            assert_eq_m128i(r, _mm_set1_epi8(6));
-        }
-        test_mm_avg_epu8();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_avg_epu16() {
+        let (a, b) = (_mm_set1_epi16(3), _mm_set1_epi16(9));
+        let r = _mm_avg_epu16(a, b);
+        assert_eq_m128i(r, _mm_set1_epi16(6));
+    }
+    test_mm_avg_epu16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_avg_epu16() {
-            let (a, b) = (_mm_set1_epi16(3), _mm_set1_epi16(9));
-            let r = _mm_avg_epu16(a, b);
-            assert_eq_m128i(r, _mm_set1_epi16(6));
-        }
-        test_mm_avg_epu16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_madd_epi16() {
-            let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
-            let b = _mm_setr_epi16(9, 10, 11, 12, 13, 14, 15, 16);
-            let r = _mm_madd_epi16(a, b);
-            let e = _mm_setr_epi32(29, 81, 149, 233);
-            assert_eq_m128i(r, e);
-
-            let a =
-                _mm_setr_epi16(i16::MAX, i16::MAX, i16::MIN, i16::MIN, i16::MIN, i16::MAX, 0, 0);
-            let b =
-                _mm_setr_epi16(i16::MAX, i16::MAX, i16::MIN, i16::MIN, i16::MAX, i16::MIN, 0, 0);
-            let r = _mm_madd_epi16(a, b);
-            let e = _mm_setr_epi32(0x7FFE0002, i32::MIN, -0x7FFF0000, 0);
-            assert_eq_m128i(r, e);
-        }
-        test_mm_madd_epi16();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_madd_epi16() {
+        let a = _mm_setr_epi16(1, 2, 3, 4, 5, 6, 7, 8);
+        let b = _mm_setr_epi16(9, 10, 11, 12, 13, 14, 15, 16);
+        let r = _mm_madd_epi16(a, b);
+        let e = _mm_setr_epi32(29, 81, 149, 233);
+        assert_eq_m128i(r, e);
+
+        let a = _mm_setr_epi16(i16::MAX, i16::MAX, i16::MIN, i16::MIN, i16::MIN, i16::MAX, 0, 0);
+        let b = _mm_setr_epi16(i16::MAX, i16::MAX, i16::MIN, i16::MIN, i16::MAX, i16::MIN, 0, 0);
+        let r = _mm_madd_epi16(a, b);
+        let e = _mm_setr_epi32(0x7FFE0002, i32::MIN, -0x7FFF0000, 0);
+        assert_eq_m128i(r, e);
+    }
+    test_mm_madd_epi16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_mulhi_epi16() {
-            let (a, b) = (_mm_set1_epi16(1000), _mm_set1_epi16(-1001));
-            let r = _mm_mulhi_epi16(a, b);
-            assert_eq_m128i(r, _mm_set1_epi16(-16));
-        }
-        test_mm_mulhi_epi16();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_mulhi_epi16() {
+        let (a, b) = (_mm_set1_epi16(1000), _mm_set1_epi16(-1001));
+        let r = _mm_mulhi_epi16(a, b);
+        assert_eq_m128i(r, _mm_set1_epi16(-16));
+    }
+    test_mm_mulhi_epi16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_mulhi_epu16() {
-            let (a, b) = (_mm_set1_epi16(1000), _mm_set1_epi16(1001));
-            let r = _mm_mulhi_epu16(a, b);
-            assert_eq_m128i(r, _mm_set1_epi16(15));
-        }
-        test_mm_mulhi_epu16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_mul_epu32() {
-            let a = _mm_setr_epi64x(1_000_000_000, 1 << 34);
-            let b = _mm_setr_epi64x(1_000_000_000, 1 << 35);
-            let r = _mm_mul_epu32(a, b);
-            let e = _mm_setr_epi64x(1_000_000_000 * 1_000_000_000, 0);
-            assert_eq_m128i(r, e);
-        }
-        test_mm_mul_epu32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_mulhi_epu16() {
+        let (a, b) = (_mm_set1_epi16(1000), _mm_set1_epi16(1001));
+        let r = _mm_mulhi_epu16(a, b);
+        assert_eq_m128i(r, _mm_set1_epi16(15));
+    }
+    test_mm_mulhi_epu16();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_mul_epu32() {
+        let a = _mm_setr_epi64x(1_000_000_000, 1 << 34);
+        let b = _mm_setr_epi64x(1_000_000_000, 1 << 35);
+        let r = _mm_mul_epu32(a, b);
+        let e = _mm_setr_epi64x(1_000_000_000 * 1_000_000_000, 0);
+        assert_eq_m128i(r, e);
+    }
+    test_mm_mul_epu32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sad_epu8() {
-            #[rustfmt::skip]
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sad_epu8() {
+        #[rustfmt::skip]
             let a = _mm_setr_epi8(
                 255u8 as i8, 254u8 as i8, 253u8 as i8, 252u8 as i8,
                 1, 2, 3, 4,
                 155u8 as i8, 154u8 as i8, 153u8 as i8, 152u8 as i8,
                 1, 2, 3, 4,
             );
-            let b = _mm_setr_epi8(0, 0, 0, 0, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2);
-            let r = _mm_sad_epu8(a, b);
-            let e = _mm_setr_epi64x(1020, 614);
-            assert_eq_m128i(r, e);
-        }
-        test_mm_sad_epu8();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sll_epi16() {
-            let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
-            let r = _mm_sll_epi16(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(
-                r,
-                _mm_setr_epi16(0xCC0, -0xCC0, 0xDD0, -0xDD0, 0xEE0, -0xEE0, 0xFF0, -0xFF0),
-            );
-            let r = _mm_sll_epi16(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_sll_epi16(a, _mm_set_epi64x(0, 16));
-            assert_eq_m128i(r, _mm_set1_epi16(0));
-            let r = _mm_sll_epi16(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi16(0));
-        }
-        test_mm_sll_epi16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_srl_epi16() {
-            let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
-            let r = _mm_srl_epi16(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_setr_epi16(0xC, 0xFF3, 0xD, 0xFF2, 0xE, 0xFF1, 0xF, 0xFF0));
-            let r = _mm_srl_epi16(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_srl_epi16(a, _mm_set_epi64x(0, 16));
-            assert_eq_m128i(r, _mm_set1_epi16(0));
-            let r = _mm_srl_epi16(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi16(0));
-        }
-        test_mm_srl_epi16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sra_epi16() {
-            let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
-            let r = _mm_sra_epi16(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_setr_epi16(0xC, -0xD, 0xD, -0xE, 0xE, -0xF, 0xF, -0x10));
-            let r = _mm_sra_epi16(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_sra_epi16(a, _mm_set_epi64x(0, 16));
-            assert_eq_m128i(r, _mm_setr_epi16(0, -1, 0, -1, 0, -1, 0, -1));
-            let r = _mm_sra_epi16(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_setr_epi16(0, -1, 0, -1, 0, -1, 0, -1));
-        }
-        test_mm_sra_epi16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sll_epi32() {
-            let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
-            let r = _mm_sll_epi32(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_setr_epi32(0xEEEE0, -0xEEEE0, 0xFFFF0, -0xFFFF0));
-            let r = _mm_sll_epi32(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_sll_epi32(a, _mm_set_epi64x(0, 32));
-            assert_eq_m128i(r, _mm_set1_epi32(0));
-            let r = _mm_sll_epi32(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi32(0));
-        }
-        test_mm_sll_epi32();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_srl_epi32() {
-            let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
-            let r = _mm_srl_epi32(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_setr_epi32(0xEEE, 0xFFFF111, 0xFFF, 0xFFFF000));
-            let r = _mm_srl_epi32(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_srl_epi32(a, _mm_set_epi64x(0, 32));
-            assert_eq_m128i(r, _mm_set1_epi32(0));
-            let r = _mm_srl_epi32(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi32(0));
-        }
-        test_mm_srl_epi32();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sra_epi32() {
-            let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
-            let r = _mm_sra_epi32(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_setr_epi32(0xEEE, -0xEEF, 0xFFF, -0x1000));
-            let r = _mm_sra_epi32(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_sra_epi32(a, _mm_set_epi64x(0, 32));
-            assert_eq_m128i(r, _mm_setr_epi32(0, -1, 0, -1));
-            let r = _mm_sra_epi32(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_setr_epi32(0, -1, 0, -1));
-        }
-        test_mm_sra_epi32();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sll_epi64() {
-            let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
-            let r = _mm_sll_epi64(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFFF0, -0xFFFFFFFF0));
-            let r = _mm_sll_epi64(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_sll_epi64(a, _mm_set_epi64x(0, 64));
-            assert_eq_m128i(r, _mm_set1_epi64x(0));
-            let r = _mm_sll_epi64(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi64x(0));
-        }
-        test_mm_sll_epi64();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_srl_epi64() {
-            let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
-            let r = _mm_srl_epi64(a, _mm_set_epi64x(0, 4));
-            assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFF, 0xFFFFFFFF0000000));
-            let r = _mm_srl_epi64(a, _mm_set_epi64x(4, 0));
-            assert_eq_m128i(r, a);
-            let r = _mm_srl_epi64(a, _mm_set_epi64x(0, 64));
-            assert_eq_m128i(r, _mm_set1_epi64x(0));
-            let r = _mm_srl_epi64(a, _mm_set_epi64x(0, i64::MAX));
-            assert_eq_m128i(r, _mm_set1_epi64x(0));
-        }
-        test_mm_srl_epi64();
+        let b = _mm_setr_epi8(0, 0, 0, 0, 2, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 2);
+        let r = _mm_sad_epu8(a, b);
+        let e = _mm_setr_epi64x(1020, 614);
+        assert_eq_m128i(r, e);
+    }
+    test_mm_sad_epu8();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtepi32_ps() {
-            let a = _mm_setr_epi32(1, 2, 3, 4);
-            let r = _mm_cvtepi32_ps(a);
-            assert_eq_m128(r, _mm_setr_ps(1.0, 2.0, 3.0, 4.0));
-        }
-        test_mm_cvtepi32_ps();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sll_epi16() {
+        let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
+        let r = _mm_sll_epi16(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(
+            r,
+            _mm_setr_epi16(0xCC0, -0xCC0, 0xDD0, -0xDD0, 0xEE0, -0xEE0, 0xFF0, -0xFF0),
+        );
+        let r = _mm_sll_epi16(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_sll_epi16(a, _mm_set_epi64x(0, 16));
+        assert_eq_m128i(r, _mm_set1_epi16(0));
+        let r = _mm_sll_epi16(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi16(0));
+    }
+    test_mm_sll_epi16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtps_epi32() {
-            let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
-            let r = _mm_cvtps_epi32(a);
-            assert_eq_m128i(r, _mm_setr_epi32(1, 2, 3, 4));
-        }
-        test_mm_cvtps_epi32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_srl_epi16() {
+        let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
+        let r = _mm_srl_epi16(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_setr_epi16(0xC, 0xFF3, 0xD, 0xFF2, 0xE, 0xFF1, 0xF, 0xFF0));
+        let r = _mm_srl_epi16(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_srl_epi16(a, _mm_set_epi64x(0, 16));
+        assert_eq_m128i(r, _mm_set1_epi16(0));
+        let r = _mm_srl_epi16(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi16(0));
+    }
+    test_mm_srl_epi16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvttps_epi32() {
-            let a = _mm_setr_ps(-1.1, 2.2, -3.3, 6.6);
-            let r = _mm_cvttps_epi32(a);
-            assert_eq_m128i(r, _mm_setr_epi32(-1, 2, -3, 6));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sra_epi16() {
+        let a = _mm_setr_epi16(0xCC, -0xCC, 0xDD, -0xDD, 0xEE, -0xEE, 0xFF, -0xFF);
+        let r = _mm_sra_epi16(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_setr_epi16(0xC, -0xD, 0xD, -0xE, 0xE, -0xF, 0xF, -0x10));
+        let r = _mm_sra_epi16(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_sra_epi16(a, _mm_set_epi64x(0, 16));
+        assert_eq_m128i(r, _mm_setr_epi16(0, -1, 0, -1, 0, -1, 0, -1));
+        let r = _mm_sra_epi16(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_setr_epi16(0, -1, 0, -1, 0, -1, 0, -1));
+    }
+    test_mm_sra_epi16();
 
-            let a = _mm_setr_ps(f32::NEG_INFINITY, f32::INFINITY, f32::MIN, f32::MAX);
-            let r = _mm_cvttps_epi32(a);
-            assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, i32::MIN, i32::MIN));
-        }
-        test_mm_cvttps_epi32();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_packs_epi16() {
-            let a = _mm_setr_epi16(0x80, -0x81, 0, 0, 0, 0, 0, 0);
-            let b = _mm_setr_epi16(0, 0, 0, 0, 0, 0, -0x81, 0x80);
-            let r = _mm_packs_epi16(a, b);
-            assert_eq_m128i(
-                r,
-                _mm_setr_epi8(0x7F, -0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0x80, 0x7F),
-            );
-        }
-        test_mm_packs_epi16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_packus_epi16() {
-            let a = _mm_setr_epi16(0x100, -1, 0, 0, 0, 0, 0, 0);
-            let b = _mm_setr_epi16(0, 0, 0, 0, 0, 0, -1, 0x100);
-            let r = _mm_packus_epi16(a, b);
-            assert_eq_m128i(r, _mm_setr_epi8(!0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, !0));
-        }
-        test_mm_packus_epi16();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_packs_epi32() {
-            let a = _mm_setr_epi32(0x8000, -0x8001, 0, 0);
-            let b = _mm_setr_epi32(0, 0, -0x8001, 0x8000);
-            let r = _mm_packs_epi32(a, b);
-            assert_eq_m128i(r, _mm_setr_epi16(0x7FFF, -0x8000, 0, 0, 0, 0, -0x8000, 0x7FFF));
-        }
-        test_mm_packs_epi32();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_min_sd() {
-            let a = _mm_setr_pd(1.0, 2.0);
-            let b = _mm_setr_pd(5.0, 10.0);
-            let r = _mm_min_sd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(1.0, 2.0));
-        }
-        test_mm_min_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_min_pd() {
-            let a = _mm_setr_pd(-1.0, 5.0);
-            let b = _mm_setr_pd(-100.0, 20.0);
-            let r = _mm_min_pd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(-100.0, 5.0));
-
-            // `_mm_min_pd` can **not** be implemented using the `simd_min` rust intrinsic because
-            // the semantics of `simd_min` are different to those of `_mm_min_pd` regarding handling
-            // of `-0.0`.
-            let a = _mm_setr_pd(-0.0, 0.0);
-            let b = _mm_setr_pd(0.0, 0.0);
-            let r1: [u8; 16] = transmute(_mm_min_pd(a, b));
-            let r2: [u8; 16] = transmute(_mm_min_pd(b, a));
-            let a: [u8; 16] = transmute(a);
-            let b: [u8; 16] = transmute(b);
-            assert_eq!(r1, b);
-            assert_eq!(r2, a);
-            assert_ne!(a, b); // sanity check that -0.0 is actually present
-        }
-        test_mm_min_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_max_sd() {
-            let a = _mm_setr_pd(1.0, 2.0);
-            let b = _mm_setr_pd(5.0, 10.0);
-            let r = _mm_max_sd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(5.0, 2.0));
-        }
-        test_mm_max_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_max_pd() {
-            let a = _mm_setr_pd(-1.0, 5.0);
-            let b = _mm_setr_pd(-100.0, 20.0);
-            let r = _mm_max_pd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(-1.0, 20.0));
-
-            // `_mm_max_pd` can **not** be implemented using the `simd_max` rust intrinsic because
-            // the semantics of `simd_max` are different to those of `_mm_max_pd` regarding handling
-            // of `-0.0`.
-            let a = _mm_setr_pd(-0.0, 0.0);
-            let b = _mm_setr_pd(0.0, 0.0);
-            let r1: [u8; 16] = transmute(_mm_max_pd(a, b));
-            let r2: [u8; 16] = transmute(_mm_max_pd(b, a));
-            let a: [u8; 16] = transmute(a);
-            let b: [u8; 16] = transmute(b);
-            assert_eq!(r1, b);
-            assert_eq!(r2, a);
-            assert_ne!(a, b); // sanity check that -0.0 is actually present
-        }
-        test_mm_max_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sqrt_sd() {
-            let a = _mm_setr_pd(1.0, 2.0);
-            let b = _mm_setr_pd(5.0, 10.0);
-            let r = _mm_sqrt_sd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(5.0f64.sqrt(), 2.0));
-        }
-        test_mm_sqrt_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sll_epi32() {
+        let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
+        let r = _mm_sll_epi32(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_setr_epi32(0xEEEE0, -0xEEEE0, 0xFFFF0, -0xFFFF0));
+        let r = _mm_sll_epi32(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_sll_epi32(a, _mm_set_epi64x(0, 32));
+        assert_eq_m128i(r, _mm_set1_epi32(0));
+        let r = _mm_sll_epi32(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi32(0));
+    }
+    test_mm_sll_epi32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_sqrt_pd() {
-            let r = _mm_sqrt_pd(_mm_setr_pd(1.0, 2.0));
-            assert_eq_m128d(r, _mm_setr_pd(1.0f64.sqrt(), 2.0f64.sqrt()));
-        }
-        test_mm_sqrt_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpeq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpeq_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpeq_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmplt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmplt_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmplt_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmple_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmple_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmple_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpgt_sd() {
-            let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpgt_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpgt_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpge_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpge_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpge_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpord_sd() {
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpord_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpord_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpunord_sd() {
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpunord_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpunord_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpneq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(!0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpneq_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpneq_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnlt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpnlt_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnlt_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnle_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpnle_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnle_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpngt_sd() {
-            let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpngt_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpngt_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnge_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, transmute(2.0f64));
-            let r = transmute::<_, __m128i>(_mm_cmpnge_sd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnge_sd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpeq_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpeq_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpeq_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmplt_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmplt_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmplt_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmple_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmple_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmple_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpgt_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpgt_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpgt_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpge_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(!0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpge_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpge_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpord_pd() {
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmpord_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpord_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpunord_pd() {
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(!0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpunord_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpunord_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpneq_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(!0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmpneq_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpneq_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnlt_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
-            let e = _mm_setr_epi64x(0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpnlt_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnlt_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnle_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, 0);
-            let r = transmute::<_, __m128i>(_mm_cmpnle_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnle_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpngt_pd() {
-            let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmpngt_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpngt_pd();
-
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cmpnge_pd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            let e = _mm_setr_epi64x(0, !0);
-            let r = transmute::<_, __m128i>(_mm_cmpnge_pd(a, b));
-            assert_eq_m128i(r, e);
-        }
-        test_mm_cmpnge_pd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_srl_epi32() {
+        let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
+        let r = _mm_srl_epi32(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_setr_epi32(0xEEE, 0xFFFF111, 0xFFF, 0xFFFF000));
+        let r = _mm_srl_epi32(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_srl_epi32(a, _mm_set_epi64x(0, 32));
+        assert_eq_m128i(r, _mm_set1_epi32(0));
+        let r = _mm_srl_epi32(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi32(0));
+    }
+    test_mm_srl_epi32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comieq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comieq_sd(a, b) != 0);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sra_epi32() {
+        let a = _mm_setr_epi32(0xEEEE, -0xEEEE, 0xFFFF, -0xFFFF);
+        let r = _mm_sra_epi32(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_setr_epi32(0xEEE, -0xEEF, 0xFFF, -0x1000));
+        let r = _mm_sra_epi32(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_sra_epi32(a, _mm_set_epi64x(0, 32));
+        assert_eq_m128i(r, _mm_setr_epi32(0, -1, 0, -1));
+        let r = _mm_sra_epi32(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_setr_epi32(0, -1, 0, -1));
+    }
+    test_mm_sra_epi32();
 
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comieq_sd(a, b) == 0);
-        }
-        test_mm_comieq_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sll_epi64() {
+        let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
+        let r = _mm_sll_epi64(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFFF0, -0xFFFFFFFF0));
+        let r = _mm_sll_epi64(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_sll_epi64(a, _mm_set_epi64x(0, 64));
+        assert_eq_m128i(r, _mm_set1_epi64x(0));
+        let r = _mm_sll_epi64(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi64x(0));
+    }
+    test_mm_sll_epi64();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comilt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comilt_sd(a, b) == 0);
-        }
-        test_mm_comilt_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_srl_epi64() {
+        let a = _mm_set_epi64x(0xFFFFFFFF, -0xFFFFFFFF);
+        let r = _mm_srl_epi64(a, _mm_set_epi64x(0, 4));
+        assert_eq_m128i(r, _mm_set_epi64x(0xFFFFFFF, 0xFFFFFFFF0000000));
+        let r = _mm_srl_epi64(a, _mm_set_epi64x(4, 0));
+        assert_eq_m128i(r, a);
+        let r = _mm_srl_epi64(a, _mm_set_epi64x(0, 64));
+        assert_eq_m128i(r, _mm_set1_epi64x(0));
+        let r = _mm_srl_epi64(a, _mm_set_epi64x(0, i64::MAX));
+        assert_eq_m128i(r, _mm_set1_epi64x(0));
+    }
+    test_mm_srl_epi64();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comile_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comile_sd(a, b) != 0);
-        }
-        test_mm_comile_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtepi32_ps() {
+        let a = _mm_setr_epi32(1, 2, 3, 4);
+        let r = _mm_cvtepi32_ps(a);
+        assert_eq_m128(r, _mm_setr_ps(1.0, 2.0, 3.0, 4.0));
+    }
+    test_mm_cvtepi32_ps();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comigt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comigt_sd(a, b) == 0);
-        }
-        test_mm_comigt_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtps_epi32() {
+        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let r = _mm_cvtps_epi32(a);
+        assert_eq_m128i(r, _mm_setr_epi32(1, 2, 3, 4));
+    }
+    test_mm_cvtps_epi32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comige_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comige_sd(a, b) != 0);
-        }
-        test_mm_comige_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvttps_epi32() {
+        let a = _mm_setr_ps(-1.1, 2.2, -3.3, 6.6);
+        let r = _mm_cvttps_epi32(a);
+        assert_eq_m128i(r, _mm_setr_epi32(-1, 2, -3, 6));
+
+        let a = _mm_setr_ps(f32::NEG_INFINITY, f32::INFINITY, f32::MIN, f32::MAX);
+        let r = _mm_cvttps_epi32(a);
+        assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, i32::MIN, i32::MIN));
+    }
+    test_mm_cvttps_epi32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_comineq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_comineq_sd(a, b) == 0);
-        }
-        test_mm_comineq_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_packs_epi16() {
+        let a = _mm_setr_epi16(0x80, -0x81, 0, 0, 0, 0, 0, 0);
+        let b = _mm_setr_epi16(0, 0, 0, 0, 0, 0, -0x81, 0x80);
+        let r = _mm_packs_epi16(a, b);
+        assert_eq_m128i(
+            r,
+            _mm_setr_epi8(0x7F, -0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0x80, 0x7F),
+        );
+    }
+    test_mm_packs_epi16();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomieq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomieq_sd(a, b) != 0);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_packus_epi16() {
+        let a = _mm_setr_epi16(0x100, -1, 0, 0, 0, 0, 0, 0);
+        let b = _mm_setr_epi16(0, 0, 0, 0, 0, 0, -1, 0x100);
+        let r = _mm_packus_epi16(a, b);
+        assert_eq_m128i(r, _mm_setr_epi8(!0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, !0));
+    }
+    test_mm_packus_epi16();
 
-            let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(NAN, 3.0));
-            assert!(_mm_ucomieq_sd(a, b) == 0);
-        }
-        test_mm_ucomieq_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_packs_epi32() {
+        let a = _mm_setr_epi32(0x8000, -0x8001, 0, 0);
+        let b = _mm_setr_epi32(0, 0, -0x8001, 0x8000);
+        let r = _mm_packs_epi32(a, b);
+        assert_eq_m128i(r, _mm_setr_epi16(0x7FFF, -0x8000, 0, 0, 0, 0, -0x8000, 0x7FFF));
+    }
+    test_mm_packs_epi32();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomilt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomilt_sd(a, b) == 0);
-        }
-        test_mm_ucomilt_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_min_sd() {
+        let a = _mm_setr_pd(1.0, 2.0);
+        let b = _mm_setr_pd(5.0, 10.0);
+        let r = _mm_min_sd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(1.0, 2.0));
+    }
+    test_mm_min_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomile_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomile_sd(a, b) != 0);
-        }
-        test_mm_ucomile_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_min_pd() {
+        let a = _mm_setr_pd(-1.0, 5.0);
+        let b = _mm_setr_pd(-100.0, 20.0);
+        let r = _mm_min_pd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(-100.0, 5.0));
+
+        // `_mm_min_pd` can **not** be implemented using the `simd_min` rust intrinsic because
+        // the semantics of `simd_min` are different to those of `_mm_min_pd` regarding handling
+        // of `-0.0`.
+        let a = _mm_setr_pd(-0.0, 0.0);
+        let b = _mm_setr_pd(0.0, 0.0);
+        let r1: [u8; 16] = transmute(_mm_min_pd(a, b));
+        let r2: [u8; 16] = transmute(_mm_min_pd(b, a));
+        let a: [u8; 16] = transmute(a);
+        let b: [u8; 16] = transmute(b);
+        assert_eq!(r1, b);
+        assert_eq!(r2, a);
+        assert_ne!(a, b); // sanity check that -0.0 is actually present
+    }
+    test_mm_min_pd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomigt_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomigt_sd(a, b) == 0);
-        }
-        test_mm_ucomigt_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_max_sd() {
+        let a = _mm_setr_pd(1.0, 2.0);
+        let b = _mm_setr_pd(5.0, 10.0);
+        let r = _mm_max_sd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(5.0, 2.0));
+    }
+    test_mm_max_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomige_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomige_sd(a, b) != 0);
-        }
-        test_mm_ucomige_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_max_pd() {
+        let a = _mm_setr_pd(-1.0, 5.0);
+        let b = _mm_setr_pd(-100.0, 20.0);
+        let r = _mm_max_pd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(-1.0, 20.0));
+
+        // `_mm_max_pd` can **not** be implemented using the `simd_max` rust intrinsic because
+        // the semantics of `simd_max` are different to those of `_mm_max_pd` regarding handling
+        // of `-0.0`.
+        let a = _mm_setr_pd(-0.0, 0.0);
+        let b = _mm_setr_pd(0.0, 0.0);
+        let r1: [u8; 16] = transmute(_mm_max_pd(a, b));
+        let r2: [u8; 16] = transmute(_mm_max_pd(b, a));
+        let a: [u8; 16] = transmute(a);
+        let b: [u8; 16] = transmute(b);
+        assert_eq!(r1, b);
+        assert_eq!(r2, a);
+        assert_ne!(a, b); // sanity check that -0.0 is actually present
+    }
+    test_mm_max_pd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_ucomineq_sd() {
-            let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
-            assert!(_mm_ucomineq_sd(a, b) == 0);
-        }
-        test_mm_ucomineq_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sqrt_sd() {
+        let a = _mm_setr_pd(1.0, 2.0);
+        let b = _mm_setr_pd(5.0, 10.0);
+        let r = _mm_sqrt_sd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(5.0f64.sqrt(), 2.0));
+    }
+    test_mm_sqrt_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtpd_ps() {
-            let r = _mm_cvtpd_ps(_mm_setr_pd(-1.0, 5.0));
-            assert_eq_m128(r, _mm_setr_ps(-1.0, 5.0, 0.0, 0.0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_sqrt_pd() {
+        let r = _mm_sqrt_pd(_mm_setr_pd(1.0, 2.0));
+        assert_eq_m128d(r, _mm_setr_pd(1.0f64.sqrt(), 2.0f64.sqrt()));
+    }
+    test_mm_sqrt_pd();
 
-            let r = _mm_cvtpd_ps(_mm_setr_pd(-1.0, -5.0));
-            assert_eq_m128(r, _mm_setr_ps(-1.0, -5.0, 0.0, 0.0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpeq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpeq_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpeq_sd();
 
-            let r = _mm_cvtpd_ps(_mm_setr_pd(f64::MAX, f64::MIN));
-            assert_eq_m128(r, _mm_setr_ps(f32::INFINITY, f32::NEG_INFINITY, 0.0, 0.0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmplt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmplt_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmplt_sd();
 
-            let r = _mm_cvtpd_ps(_mm_setr_pd(f32::MAX as f64, f32::MIN as f64));
-            assert_eq_m128(r, _mm_setr_ps(f32::MAX, f32::MIN, 0.0, 0.0));
-        }
-        test_mm_cvtpd_ps();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmple_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmple_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmple_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtps_pd() {
-            let r = _mm_cvtps_pd(_mm_setr_ps(-1.0, 2.0, -3.0, 5.0));
-            assert_eq_m128d(r, _mm_setr_pd(-1.0, 2.0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpgt_sd() {
+        let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpgt_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpgt_sd();
 
-            let r = _mm_cvtps_pd(_mm_setr_ps(f32::MAX, f32::INFINITY, f32::NEG_INFINITY, f32::MIN));
-            assert_eq_m128d(r, _mm_setr_pd(f32::MAX as f64, f64::INFINITY));
-        }
-        test_mm_cvtps_pd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpge_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpge_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpge_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtpd_epi32() {
-            let r = _mm_cvtpd_epi32(_mm_setr_pd(-1.0, 5.0));
-            assert_eq_m128i(r, _mm_setr_epi32(-1, 5, 0, 0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpord_sd() {
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpord_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpord_sd();
 
-            let r = _mm_cvtpd_epi32(_mm_setr_pd(-1.0, -5.0));
-            assert_eq_m128i(r, _mm_setr_epi32(-1, -5, 0, 0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpunord_sd() {
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpunord_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpunord_sd();
 
-            let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::MAX, f64::MIN));
-            assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpneq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(!0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpneq_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpneq_sd();
 
-            let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::INFINITY, f64::NEG_INFINITY));
-            assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnlt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpnlt_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnlt_sd();
 
-            let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::NAN, f64::NAN));
-            assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
-        }
-        test_mm_cvtpd_epi32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnle_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpnle_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnle_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvttpd_epi32() {
-            let a = _mm_setr_pd(-1.1, 2.2);
-            let r = _mm_cvttpd_epi32(a);
-            assert_eq_m128i(r, _mm_setr_epi32(-1, 2, 0, 0));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpngt_sd() {
+        let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpngt_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpngt_sd();
 
-            let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
-            let r = _mm_cvttpd_epi32(a);
-            assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
-        }
-        test_mm_cvttpd_epi32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnge_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, transmute(2.0f64));
+        let r = transmute::<_, __m128i>(_mm_cmpnge_sd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnge_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtsd_si32() {
-            let r = _mm_cvtsd_si32(_mm_setr_pd(-2.0, 5.0));
-            assert_eq!(r, -2);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpeq_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpeq_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpeq_pd();
 
-            let r = _mm_cvtsd_si32(_mm_setr_pd(f64::MAX, f64::MIN));
-            assert_eq!(r, i32::MIN);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmplt_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmplt_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmplt_pd();
 
-            let r = _mm_cvtsd_si32(_mm_setr_pd(f64::NAN, f64::NAN));
-            assert_eq!(r, i32::MIN);
-        }
-        test_mm_cvtsd_si32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmple_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmple_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmple_pd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvttsd_si32() {
-            let a = _mm_setr_pd(-1.1, 2.2);
-            let r = _mm_cvttsd_si32(a);
-            assert_eq!(r, -1);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpgt_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpgt_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpgt_pd();
 
-            let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
-            let r = _mm_cvttsd_si32(a);
-            assert_eq!(r, i32::MIN);
-        }
-        test_mm_cvttsd_si32();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpge_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(!0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpge_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpge_pd();
 
-        // Intrinsic only available on x86_64
-        #[cfg(target_arch = "x86_64")]
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtsd_si64() {
-            let r = _mm_cvtsd_si64(_mm_setr_pd(-2.0, 5.0));
-            assert_eq!(r, -2_i64);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpord_pd() {
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmpord_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpord_pd();
 
-            let r = _mm_cvtsd_si64(_mm_setr_pd(f64::MAX, f64::MIN));
-            assert_eq!(r, i64::MIN);
-        }
-        #[cfg(target_arch = "x86_64")]
-        test_mm_cvtsd_si64();
-
-        // Intrinsic only available on x86_64
-        #[cfg(target_arch = "x86_64")]
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvttsd_si64() {
-            let a = _mm_setr_pd(-1.1, 2.2);
-            let r = _mm_cvttsd_si64(a);
-            assert_eq!(r, -1_i64);
-        }
-        #[cfg(target_arch = "x86_64")]
-        test_mm_cvttsd_si64();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpunord_pd() {
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(!0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpunord_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpunord_pd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtsd_ss() {
-            let a = _mm_setr_ps(-1.1, -2.2, 3.3, 4.4);
-            let b = _mm_setr_pd(2.0, -5.0);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpneq_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(!0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmpneq_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpneq_pd();
 
-            let r = _mm_cvtsd_ss(a, b);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnlt_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(5.0, 3.0));
+        let e = _mm_setr_epi64x(0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpnlt_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnlt_pd();
 
-            assert_eq_m128(r, _mm_setr_ps(2.0, -2.2, 3.3, 4.4));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnle_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, 0);
+        let r = transmute::<_, __m128i>(_mm_cmpnle_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnle_pd();
 
-            let a = _mm_setr_ps(-1.1, f32::NEG_INFINITY, f32::MAX, f32::NEG_INFINITY);
-            let b = _mm_setr_pd(f64::INFINITY, -5.0);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpngt_pd() {
+        let (a, b) = (_mm_setr_pd(5.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmpngt_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpngt_pd();
 
-            let r = _mm_cvtsd_ss(a, b);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cmpnge_pd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        let e = _mm_setr_epi64x(0, !0);
+        let r = transmute::<_, __m128i>(_mm_cmpnge_pd(a, b));
+        assert_eq_m128i(r, e);
+    }
+    test_mm_cmpnge_pd();
 
-            assert_eq_m128(
-                r,
-                _mm_setr_ps(f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::NEG_INFINITY),
-            );
-        }
-        test_mm_cvtsd_ss();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comieq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comieq_sd(a, b) != 0);
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_cvtss_sd() {
-            let a = _mm_setr_pd(-1.1, 2.2);
-            let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comieq_sd(a, b) == 0);
+    }
+    test_mm_comieq_sd();
 
-            let r = _mm_cvtss_sd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(1.0, 2.2));
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comilt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comilt_sd(a, b) == 0);
+    }
+    test_mm_comilt_sd();
 
-            let a = _mm_setr_pd(-1.1, f64::INFINITY);
-            let b = _mm_setr_ps(f32::NEG_INFINITY, 2.0, 3.0, 4.0);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comile_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comile_sd(a, b) != 0);
+    }
+    test_mm_comile_sd();
 
-            let r = _mm_cvtss_sd(a, b);
-            assert_eq_m128d(r, _mm_setr_pd(f64::NEG_INFINITY, f64::INFINITY));
-        }
-        test_mm_cvtss_sd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comigt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comigt_sd(a, b) == 0);
+    }
+    test_mm_comigt_sd();
 
-        #[target_feature(enable = "sse2")]
-        unsafe fn test_mm_movemask_pd() {
-            let r = _mm_movemask_pd(_mm_setr_pd(-1.0, 5.0));
-            assert_eq!(r, 0b01);
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comige_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comige_sd(a, b) != 0);
+    }
+    test_mm_comige_sd();
 
-            let r = _mm_movemask_pd(_mm_setr_pd(-1.0, -5.0));
-            assert_eq!(r, 0b11);
-        }
-        test_mm_movemask_pd();
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_comineq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_comineq_sd(a, b) == 0);
+    }
+    test_mm_comineq_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomieq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomieq_sd(a, b) != 0);
+
+        let (a, b) = (_mm_setr_pd(NAN, 2.0), _mm_setr_pd(NAN, 3.0));
+        assert!(_mm_ucomieq_sd(a, b) == 0);
+    }
+    test_mm_ucomieq_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomilt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomilt_sd(a, b) == 0);
+    }
+    test_mm_ucomilt_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomile_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomile_sd(a, b) != 0);
+    }
+    test_mm_ucomile_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomigt_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomigt_sd(a, b) == 0);
+    }
+    test_mm_ucomigt_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomige_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomige_sd(a, b) != 0);
+    }
+    test_mm_ucomige_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_ucomineq_sd() {
+        let (a, b) = (_mm_setr_pd(1.0, 2.0), _mm_setr_pd(1.0, 3.0));
+        assert!(_mm_ucomineq_sd(a, b) == 0);
+    }
+    test_mm_ucomineq_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtpd_ps() {
+        let r = _mm_cvtpd_ps(_mm_setr_pd(-1.0, 5.0));
+        assert_eq_m128(r, _mm_setr_ps(-1.0, 5.0, 0.0, 0.0));
+
+        let r = _mm_cvtpd_ps(_mm_setr_pd(-1.0, -5.0));
+        assert_eq_m128(r, _mm_setr_ps(-1.0, -5.0, 0.0, 0.0));
+
+        let r = _mm_cvtpd_ps(_mm_setr_pd(f64::MAX, f64::MIN));
+        assert_eq_m128(r, _mm_setr_ps(f32::INFINITY, f32::NEG_INFINITY, 0.0, 0.0));
+
+        let r = _mm_cvtpd_ps(_mm_setr_pd(f32::MAX as f64, f32::MIN as f64));
+        assert_eq_m128(r, _mm_setr_ps(f32::MAX, f32::MIN, 0.0, 0.0));
+    }
+    test_mm_cvtpd_ps();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtps_pd() {
+        let r = _mm_cvtps_pd(_mm_setr_ps(-1.0, 2.0, -3.0, 5.0));
+        assert_eq_m128d(r, _mm_setr_pd(-1.0, 2.0));
+
+        let r = _mm_cvtps_pd(_mm_setr_ps(f32::MAX, f32::INFINITY, f32::NEG_INFINITY, f32::MIN));
+        assert_eq_m128d(r, _mm_setr_pd(f32::MAX as f64, f64::INFINITY));
+    }
+    test_mm_cvtps_pd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtpd_epi32() {
+        let r = _mm_cvtpd_epi32(_mm_setr_pd(-1.0, 5.0));
+        assert_eq_m128i(r, _mm_setr_epi32(-1, 5, 0, 0));
+
+        let r = _mm_cvtpd_epi32(_mm_setr_pd(-1.0, -5.0));
+        assert_eq_m128i(r, _mm_setr_epi32(-1, -5, 0, 0));
+
+        let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::MAX, f64::MIN));
+        assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+
+        let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::INFINITY, f64::NEG_INFINITY));
+        assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+
+        let r = _mm_cvtpd_epi32(_mm_setr_pd(f64::NAN, f64::NAN));
+        assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+    }
+    test_mm_cvtpd_epi32();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvttpd_epi32() {
+        let a = _mm_setr_pd(-1.1, 2.2);
+        let r = _mm_cvttpd_epi32(a);
+        assert_eq_m128i(r, _mm_setr_epi32(-1, 2, 0, 0));
+
+        let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
+        let r = _mm_cvttpd_epi32(a);
+        assert_eq_m128i(r, _mm_setr_epi32(i32::MIN, i32::MIN, 0, 0));
+    }
+    test_mm_cvttpd_epi32();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtsd_si32() {
+        let r = _mm_cvtsd_si32(_mm_setr_pd(-2.0, 5.0));
+        assert_eq!(r, -2);
+
+        let r = _mm_cvtsd_si32(_mm_setr_pd(f64::MAX, f64::MIN));
+        assert_eq!(r, i32::MIN);
+
+        let r = _mm_cvtsd_si32(_mm_setr_pd(f64::NAN, f64::NAN));
+        assert_eq!(r, i32::MIN);
+    }
+    test_mm_cvtsd_si32();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvttsd_si32() {
+        let a = _mm_setr_pd(-1.1, 2.2);
+        let r = _mm_cvttsd_si32(a);
+        assert_eq!(r, -1);
+
+        let a = _mm_setr_pd(f64::NEG_INFINITY, f64::NAN);
+        let r = _mm_cvttsd_si32(a);
+        assert_eq!(r, i32::MIN);
+    }
+    test_mm_cvttsd_si32();
+
+    // Intrinsic only available on x86_64
+    #[cfg(target_arch = "x86_64")]
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtsd_si64() {
+        let r = _mm_cvtsd_si64(_mm_setr_pd(-2.0, 5.0));
+        assert_eq!(r, -2_i64);
+
+        let r = _mm_cvtsd_si64(_mm_setr_pd(f64::MAX, f64::MIN));
+        assert_eq!(r, i64::MIN);
+    }
+    #[cfg(target_arch = "x86_64")]
+    test_mm_cvtsd_si64();
+
+    // Intrinsic only available on x86_64
+    #[cfg(target_arch = "x86_64")]
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvttsd_si64() {
+        let a = _mm_setr_pd(-1.1, 2.2);
+        let r = _mm_cvttsd_si64(a);
+        assert_eq!(r, -1_i64);
+    }
+    #[cfg(target_arch = "x86_64")]
+    test_mm_cvttsd_si64();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtsd_ss() {
+        let a = _mm_setr_ps(-1.1, -2.2, 3.3, 4.4);
+        let b = _mm_setr_pd(2.0, -5.0);
+
+        let r = _mm_cvtsd_ss(a, b);
+
+        assert_eq_m128(r, _mm_setr_ps(2.0, -2.2, 3.3, 4.4));
+
+        let a = _mm_setr_ps(-1.1, f32::NEG_INFINITY, f32::MAX, f32::NEG_INFINITY);
+        let b = _mm_setr_pd(f64::INFINITY, -5.0);
+
+        let r = _mm_cvtsd_ss(a, b);
+
+        assert_eq_m128(
+            r,
+            _mm_setr_ps(f32::INFINITY, f32::NEG_INFINITY, f32::MAX, f32::NEG_INFINITY),
+        );
+    }
+    test_mm_cvtsd_ss();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_cvtss_sd() {
+        let a = _mm_setr_pd(-1.1, 2.2);
+        let b = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
+
+        let r = _mm_cvtss_sd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(1.0, 2.2));
+
+        let a = _mm_setr_pd(-1.1, f64::INFINITY);
+        let b = _mm_setr_ps(f32::NEG_INFINITY, 2.0, 3.0, 4.0);
+
+        let r = _mm_cvtss_sd(a, b);
+        assert_eq_m128d(r, _mm_setr_pd(f64::NEG_INFINITY, f64::INFINITY));
+    }
+    test_mm_cvtss_sd();
+
+    #[target_feature(enable = "sse2")]
+    unsafe fn test_mm_movemask_pd() {
+        let r = _mm_movemask_pd(_mm_setr_pd(-1.0, 5.0));
+        assert_eq!(r, 0b01);
+
+        let r = _mm_movemask_pd(_mm_setr_pd(-1.0, -5.0));
+        assert_eq!(r, 0b11);
     }
+    test_mm_movemask_pd();
 }
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index 1b5c98cd51826..5d636431d8675 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -8,7 +8,7 @@
 // the RNG and always read the latest value from the store buffer.
 
 use std::sync::atomic::Ordering::*;
-use std::sync::atomic::{fence, AtomicUsize};
+use std::sync::atomic::{AtomicUsize, fence};
 use std::thread::spawn;
 
 #[allow(dead_code)]
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index d405eb92ad14e..2430140eea1d4 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -12,7 +12,7 @@ use ui_test::custom_flags::edition::Edition;
 use ui_test::dependencies::DependencyBuilder;
 use ui_test::per_test_config::TestConfig;
 use ui_test::spanned::Spanned;
-use ui_test::{status_emitter, CommandBuilder, Config, Format, Match, OutputConflictHandling};
+use ui_test::{CommandBuilder, Config, Format, Match, OutputConflictHandling, status_emitter};
 
 #[derive(Copy, Clone, Debug)]
 enum Mode {
@@ -118,24 +118,21 @@ fn miri_config(target: &str, path: &str, mode: Mode, with_dependencies: bool) ->
     config.comment_defaults.base().add_custom("edition", Edition("2021".into()));
 
     if with_dependencies {
-        config.comment_defaults.base().set_custom(
-            "dependencies",
-            DependencyBuilder {
-                program: CommandBuilder {
-                    // Set the `cargo-miri` binary, which we expect to be in the same folder as the `miri` binary.
-                    // (It's a separate crate, so we don't get an env var from cargo.)
-                    program: miri_path()
-                        .with_file_name(format!("cargo-miri{}", env::consts::EXE_SUFFIX)),
-                    // There is no `cargo miri build` so we just use `cargo miri run`.
-                    args: ["miri", "run"].into_iter().map(Into::into).collect(),
-                    // Reset `RUSTFLAGS` to work around <https://github.com/rust-lang/rust/pull/119574#issuecomment-1876878344>.
-                    envs: vec![("RUSTFLAGS".into(), None)],
-                    ..CommandBuilder::cargo()
-                },
-                crate_manifest_path: Path::new("test_dependencies").join("Cargo.toml"),
-                build_std: None,
+        config.comment_defaults.base().set_custom("dependencies", DependencyBuilder {
+            program: CommandBuilder {
+                // Set the `cargo-miri` binary, which we expect to be in the same folder as the `miri` binary.
+                // (It's a separate crate, so we don't get an env var from cargo.)
+                program: miri_path()
+                    .with_file_name(format!("cargo-miri{}", env::consts::EXE_SUFFIX)),
+                // There is no `cargo miri build` so we just use `cargo miri run`.
+                args: ["miri", "run"].into_iter().map(Into::into).collect(),
+                // Reset `RUSTFLAGS` to work around <https://github.com/rust-lang/rust/pull/119574#issuecomment-1876878344>.
+                envs: vec![("RUSTFLAGS".into(), None)],
+                ..CommandBuilder::cargo()
             },
-        );
+            crate_manifest_path: Path::new("test_dependencies").join("Cargo.toml"),
+            build_std: None,
+        });
     }
     config
 }